LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-shortreadsort.c
// Function: gt_shortreadsort_size
static size_t gt_shortreadsort_size_perbucketentry(bool firstcodes,
                                                   GtUword maxremain)
{
  return (firstcodes ? sizeof (uint16_t) : 0) +
         sizeof (GtShortreadsort) + sizeof (GtUword) +
         sizeof (GtTwobitencoding) *
         gt_shortreadsort_encoding_factor(maxremain);
}

// Assembly:
testl %edi, %edi
jne 0x1f519e
movsd 0x1c4dfc(%rip), %xmm0   # 0x3b9f98
jmp 0x1f51a6
movsd 0x1c4dea(%rip), %xmm0   # 0x3b9f90
movsd 0x15107a(%rip), %xmm1   # 0x346228
cmpq $0x41, %rdx
jb 0x1f51c1
shrq $0x6, %rdx
cvtsi2sd %rdx, %xmm2
addsd %xmm2, %xmm1
mulsd 0x186b57(%rip), %xmm1   # 0x37bd20
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x152b3f(%rip), %xmm1   # 0x347d20
cvttsd2si %xmm1, %rax
andq %rdx, %rax
orq %rcx, %rax
imulq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-shortreadsort.c
// Function: gt_shortreadsort_new
GtShortreadsortworkinfo *gt_shortreadsort_new(GtUword maxwidth,
                                              GtUword maxremain,
                                              GtReadmode readmode,
                                              bool firstcodes,
                                              bool withmediumsizelcps)
{
  GtShortreadsortworkinfo *srsw;

  srsw = gt_malloc(sizeof (*srsw));
  srsw->fwd = GT_ISDIRREVERSE(readmode) ? false : true;
  srsw->complement = GT_ISDIRCOMPLEMENT(readmode) ? true : false;
  srsw->sssplcpvalues = NULL;
  srsw->sumofstoredvalues = 0;
  srsw->currentbucketsize = 0;
  srsw->shortreadsorttable = NULL;
  srsw->mediumsizelcpvalues = NULL;
  srsw->withmediumsizelcps = withmediumsizelcps;
  srsw->seqnum_relpos_bucket = NULL;
  GT_INITARRAY(&srsw->tbereservoir,GtTwobitencoding);
  if (maxwidth > 0)
  {
    gt_shortreadsort_resize(srsw,firstcodes,maxwidth,maxremain);
  }
  return srsw;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1c4d2a(%rip), %rsi    # 0x3b9fa0
movl $0x58, %edi
movl $0x8e, %edx
callq 0x104226
movq %rax, %r15
movl %r13d, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
setne 0x50(%r15)
andl $-0x2, %r13d
cmpl $0x2, %r13d
sete 0x51(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movups %xmm0, 0x40(%r15)
movb %r12b, 0x52(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x28(%r15)
testq %r14, %r14
je 0x1f52dc
movzbl %bpl, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1f52ee
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-shortreadsort.c
// Function: gt_shortreadsort_delete
void gt_shortreadsort_delete(GtShortreadsortworkinfo *srsw)
{
  if (srsw != NULL)
  {
    gt_free(srsw->shortreadsorttable);
    srsw->shortreadsorttable = NULL;
    gt_free(srsw->mediumsizelcpvalues);
    srsw->mediumsizelcpvalues = NULL;
    gt_free(srsw->seqnum_relpos_bucket);
    srsw->seqnum_relpos_bucket = NULL;
    GT_FREEARRAY(&srsw->tbereservoir,GtTwobitencoding);
    gt_free(srsw);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1f54cb
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x1c4b58(%rip), %r14    # 0x3b9fa0
movq %r14, %rsi
movl $0xa9, %edx
callq 0x1045eb
xorl %r15d, %r15d
movq %r15, (%rbx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0xab, %edx
callq 0x1045eb
movq %r15, 0x10(%rbx)
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0xad, %edx
callq 0x1045eb
movq %r15, 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1f54b2
leaq 0x20(%rbx), %r14
leaq 0x1c4b07(%rip), %rsi    # 0x3b9fa0
movl $0xaf, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x1c4ae7(%rip), %rsi    # 0x3b9fa0
movq %rbx, %rdi
movl $0xb0, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: getencseqkmersinsertkmerwithoutspecial
void getencseqkmersinsertkmerwithoutspecial(const GtEncseq *encseq,
                                            GtReadmode readmode,
                                            unsigned int kmersize,
                                            Sfxiterator *sfi)
{
  GtKmercodeiterator *kmercodeiterator;
  const GtKmercode *kmercodeptr;

  kmercodeiterator = gt_kmercodeiterator_encseq_new(encseq,readmode,kmersize,0);
  if (!gt_kmercodeiterator_inputexhausted(kmercodeiterator))
  {
    GtUword position = 0;

    while ((kmercodeptr = gt_kmercodeiterator_encseq_next(kmercodeiterator))
                          != NULL)
    {
      gt_insertkmerwithoutspecial(sfi,position++,kmercodeptr);
    }
    gt_kmercodeiterator_delete(kmercodeiterator);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
xorl %ecx, %ecx
callq 0x1ee606
movq %rax, %r14
movq %rax, %rdi
callq 0x1eebc2
testb %al, %al
je 0x1f6a54
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1ee7e3
testq %rax, %rax
je 0x1f6a82
xorl %esi, %esi
leaq 0x1(%rsi), %r15
movq %rbx, %rdi
movq %rax, %rdx
callq 0x1f6a8f
movq %r14, %rdi
callq 0x1ee7e3
movq %r15, %rsi
testq %rax, %rax
jne 0x1f6a63
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1eeaa9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_sfimarkprefixsuffixbuckets
static void gt_sfimarkprefixsuffixbuckets(void *processinfo,
                                          GT_UNUSED bool firstinrange,
                                          GT_UNUSED GtUword pos,
                                          GtCodetype scancode)
{
  Sfxiterator *sfi = (Sfxiterator *) processinfo;
  GtCodetype checkcode = GT_SCANCODE_TO_PREFIXCODE(sfi,scancode);

  gt_assert(firstinrange);
  if (!GT_ISIBITSET(sfi->markprefixbuckets,checkcode))
  {
    GT_SETIBIT(sfi->markprefixbuckets,checkcode);
  }
#if defined (_LP64) || defined (_WIN64)
  checkcode = GT_SCANCODE_TO_SUFFIXCODE(sfi,scancode);
  if (!GT_ISIBITSET(sfi->marksuffixbuckets,checkcode))
  {
    GT_SETIBIT(sfi->marksuffixbuckets,checkcode);
  }
#endif
}

// Assembly:
testl %esi, %esi
je 0x1f8a28
movq %rcx, %rax
movb 0x128(%rdi), %cl
movq %rax, %rdx
shrq %cl, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
movq 0x130(%rdi), %r8
movq %rdx, %r9
shrq $0x6, %r9
movq (%r8,%r9,8), %r10
movq %rsi, %r11
movl %edx, %ecx
shrq %cl, %r11
testq %r10, %r11
jne 0x1f89fc
orq %r10, %r11
movq %r11, (%r8,%r9,8)
andq 0x140(%rdi), %rax
movq 0x138(%rdi), %rdx
movq %rax, %rdi
shrq $0x6, %rdi
movq (%rdx,%rdi,8), %r8
movl %eax, %ecx
shrq %cl, %rsi
testq %r8, %rsi
je 0x1f8a20
retq
orq %r8, %rsi
movq %rsi, (%rdx,%rdi,8)
retq
pushq %rax
callq 0x7c833
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_Sfxiterator_bcktab2file
int gt_Sfxiterator_bcktab2file(FILE *fp, Sfxiterator *sfi, GtError *err)
{
  gt_error_check(err);
  gt_assert(sfi != NULL && sfi->bcktab != NULL);
  if (gt_suftabparts_numofparts(sfi->suftabparts) <= 1U)
  {
    int ret = gt_bcktab_flush_to_file(fp,sfi->bcktab,err);
    gt_fa_fclose(fp);
    return ret;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1f95aa
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1f95f3
testq %r15, %r15
je 0x1f95ee
cmpq $0x0, 0x78(%r15)
je 0x1f95ee
movq 0x68(%r15), %rdi
callq 0x1eff10
cmpl $0x1, %eax
ja 0x1f95e1
movq 0x78(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x18b708
movl %eax, %ebp
movq %rbx, %rdi
callq 0xfd018
movl %ebp, %eax
jmp 0x1f95e3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x7cde9
callq 0x7cdb0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_Sfxiterator_longest
GtUword gt_Sfxiterator_longest(const Sfxiterator *sfi)
{
  gt_assert(sfi != NULL);
  if (sfi->sfxstrategy.spmopt_minlength == 0)
  {
    return gt_suffixsortspace_longest(sfi->suffixsortspace);
  } else
  {
    return 0;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1f9612
cmpl $0x0, 0x50(%rdi)
je 0x1f9606
xorl %eax, %eax
retq
movq 0x90(%rdi), %rdi
jmp 0x1fcc62
pushq %rax
callq 0x7ce22
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_checksuffixprefixbuckets
static bool gt_checksuffixprefixbuckets(const Sfxiterator *sfi,
                                        GtCodetype scancode)
{
  GtCodetype prefixcode = GT_SCANCODE_TO_PREFIXCODE(sfi,scancode);
  GtCodetype suffixcode = GT_SCANCODE_TO_SUFFIXCODE(sfi,scancode);

  gt_assert(prefixcode < sfi->spmopt_numofallprefixcodes);
  gt_assert(suffixcode < sfi->spmopt_numofallsuffixcodes);
  return (GT_ISIBITSET(sfi->markprefixbuckets,prefixcode) &&
          GT_ISIBITSET(sfi->marksuffixbuckets,suffixcode)) ? true : false;
}

// Assembly:
pushq %rax
movb 0x128(%rdi), %cl
movq %rsi, %rax
shrq %cl, %rax
cmpq 0x148(%rdi), %rax
jae 0x1f9685
andq 0x140(%rdi), %rsi
cmpq 0x150(%rdi), %rsi
jae 0x1f968a
movq 0x130(%rdi), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rdx
movl %eax, %ecx
shlq %cl, %rdx
shrq $0x3f, %rdx
je 0x1f9681
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq 0x138(%rdi), %rdx
movq %rsi, %rdi
movl %esi, %ecx
shrq %cl, %rax
shrq $0x6, %rdi
testq %rax, (%rdx,%rdi,8)
setne %al
jmp 0x1f9683
xorl %eax, %eax
popq %rcx
retq
callq 0x7ce5b
callq 0x7ce94
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_updateleftborderforspecialkmer
static void gt_updateleftborderforspecialkmer(Sfxiterator *sfi,
                                              unsigned int maxprefixindex,
                                              GtUword position,
                                              unsigned int code)
{
  unsigned int idx;

  gt_assert(sfi->sfxstrategy.spmopt_minlength == 0);
  if (sfi->sfxstrategy.storespecialcodes)
  {
    Codeatposition *spcaptr;
    spcaptr = sfi->spaceCodeatposition + sfi->nextfreeCodeatposition++;
    spcaptr->maxprefixindex = maxprefixindex;
    spcaptr->code = code;
    spcaptr->position = position;
  }
  for (idx=maxprefixindex; idx>=1U; idx--)
  {
    gt_bcktab_leftborder_addcode(sfi->leftborder,(GtCodetype) code);
    code = ((code << 2) | 3U) & sfi->kmerfastmaskright;
  }
}

// Assembly:
pushq %rax
cmpl $0x0, 0x50(%rdi)
jne 0x1fb625
cmpb $0x1, 0x55(%rdi)
jne 0x1fb5d8
movq 0x100(%rdi), %rax
movq 0x108(%rdi), %r8
leaq 0x1(%rax), %r9
movq %r9, 0x100(%rdi)
shlq $0x4, %rax
movl %esi, %r9d
andl $0xf, %r9d
movl %ecx, %r10d
shll $0x4, %r10d
orl %r9d, %r10d
movl %r10d, (%r8,%rax)
movq %rdx, 0x8(%r8,%rax)
testl %esi, %esi
je 0x1fb61e
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x1fb62a
movq 0x8(%rax), %rdx
movl %ecx, %ecx
testq %rdx, %rdx
je 0x1fb5f9
incq (%rdx,%rcx,8)
jmp 0x1fb60d
movq (%rax), %r8
movl (%r8,%rcx,4), %r9d
cmpl $-0x1, %r9d
je 0x1fb620
incl %r9d
movl %r9d, (%r8,%rcx,4)
leal 0x3(,%rcx,4), %ecx
andl 0x110(%rdi), %ecx
decl %esi
jne 0x1fb5ec
popq %rax
retq
callq 0x7d0ae
callq 0x7d075
callq 0x7d0e5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_suffixer_sort_with_dcov
static void gt_suffixer_sort_with_dcov(void *voidsfi,
                                       GtSuffixsortspace *sssp,
                                       GtUword blisbl,
                                       GtUword width,
                                       GtUword depth)
{
  Sfxiterator *sfi = (Sfxiterator *) voidsfi;

  gt_assert(sfi != NULL);
  gt_differencecover_sortunsortedbucket(sssp,
                                        gt_Outlcpinfo_lcpvalues_ref(
                                               sfi->outlcpinfo),
                                        sfi->dcov, blisbl, width,depth);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1fbb87
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0xb8(%rdi), %rdi
callq 0x1ed034
movq 0x88(%r13), %rdx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1ea0aa
callq 0x7d5dc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_clone
GtSuffixsortspace *gt_suffixsortspace_clone(GtSuffixsortspace *sssp,
                                            unsigned int clonenumber,
                                            GtLogger *logger)
{
  bool useuint;
  void *tab2clone;
  GtSuffixsortspace *cloned_sssp;

  gt_assert(sssp != NULL);
  useuint = sssp->uinttab != NULL ? true : false;
  tab2clone = useuint ? (void *) sssp->uinttab
                      : (void *) sssp->ulongtab;
  gt_assert(tab2clone != NULL);
  cloned_sssp = gt_suffixsortspace_new_generic(sssp->maxindex + 1,
                                               sssp->maxvalue,
                                               useuint,
                                               tab2clone,
                                               logger);
  gt_assert(clonenumber > 0);
  cloned_sssp->clonenumber = clonenumber;
  cloned_sssp->partoffset = sssp->partoffset;
  return cloned_sssp;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1fc756
movq %rdx, %r8
movl %esi, %ebp
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq %rax, %rcx
testq %rax, %rax
jne 0x1fc728
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x1fc760
xorl %edx, %edx
testq %rax, %rax
setne %dl
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
incq %rdi
callq 0x1fc57f
testl %ebp, %ebp
je 0x1fc75b
movl %ebp, 0x4(%rax)
movq 0x38(%rbx), %rcx
movq %rcx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x7dd6b
callq 0x7dd32
callq 0x7dcf9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_delete
void gt_suffixsortspace_delete(GtSuffixsortspace *suffixsortspace,
                               bool checklongestdefined)
{
  if (suffixsortspace != NULL)
  {
    if (checklongestdefined && !suffixsortspace->longestidx.defined)
    {
      fprintf(stderr,"%s, l. %d: longest is not defined\n",__FILE__,__LINE__);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    if (suffixsortspace->clonenumber == 0)
    {
      gt_free(suffixsortspace->uinttab);
      gt_free(suffixsortspace->ulongtab);
    }
    gt_free(suffixsortspace);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1fc7c6
movq %rdi, %rbx
testb %sil, %sil
je 0x1fc77c
cmpb $0x0, 0x8(%rbx)
je 0x1fc7ce
cmpl $0x0, 0x4(%rbx)
jne 0x1fc7ab
movq 0x58(%rbx), %rdi
leaq 0x1be7cb(%rip), %r14    # 0x3baf58
movq %r14, %rsi
movl $0xcd, %edx
callq 0x1045eb
movq 0x50(%rbx), %rdi
movq %r14, %rsi
movl $0xce, %edx
callq 0x1045eb
leaq 0x1be7a6(%rip), %rsi    # 0x3baf58
movq %rbx, %rdi
movl $0xd0, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x7dda4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_getdirect
GtUword gt_suffixsortspace_getdirect(const GtSuffixsortspace *sssp,GtUword idx)
{
  gt_assert(sssp != NULL && idx <= sssp->maxindex);
  if (sssp->ulongtab != NULL)
  {
    return sssp->ulongtab[idx];
  }
  gt_assert(sssp->uinttab != NULL);
  return (GtUword) sssp->uinttab[idx];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1fc816
cmpq %rsi, 0x28(%rdi)
jb 0x1fc816
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1fc808
movq (%rax,%rsi,8), %rax
jmp 0x1fc814
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1fc81b
movl (%rax,%rsi,4), %eax
popq %rcx
retq
callq 0x7de43
callq 0x7de0a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_showrange
void gt_suffixsortspace_showrange(const GtSuffixsortspace *sssp,
                                  GtUword subbucketleft,
                                  GtUword width)
{
  GtUword idx;

  gt_assert(sssp != NULL);
  printf(GT_WU","GT_WU"=",sssp->bucketleftidx+subbucketleft-sssp->partoffset,
                    sssp->bucketleftidx+subbucketleft+width-1-sssp->partoffset);
  for (idx=sssp->bucketleftidx+subbucketleft-sssp->partoffset;
       idx<sssp->bucketleftidx+subbucketleft+width-sssp->partoffset;
       idx++)
  {
    printf(" "GT_WU, gt_suffixsortspace_getdirect(sssp,idx));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1fc8d5
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x40(%rdi), %rax
addq %rsi, %rax
movq 0x38(%rdi), %rdx
movq %rax, %rsi
subq %rdx, %rsi
addq %rbx, %rax
notq %rdx
addq %rax, %rdx
leaq 0x1be863(%rip), %rdi    # 0x3bb0d6
xorl %eax, %eax
callq 0x17070
movq 0x38(%r14), %rax
movq 0x40(%r14), %rcx
leaq (%rcx,%r12), %r15
subq %rax, %r15
addq %r12, %rbx
addq %rbx, %rcx
subq %rax, %rcx
cmpq %rcx, %r15
jae 0x1fc8c9
leaq 0x1b3be5(%rip), %r12    # 0x3b0483
movq %r14, %rdi
movq %r15, %rsi
callq 0x1fc7ed
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
incq %r15
movq 0x40(%r14), %rax
addq %rbx, %rax
subq 0x38(%r14), %rax
cmpq %rax, %r15
jb 0x1fc89e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x7deb5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_exportptr
GtSuffixsortspace_exportptr *gt_suffixsortspace_exportptr(
                                  GtSuffixsortspace *sssp,
                                  GtUword subbucketleft)
{
  gt_assert(sssp != NULL);
  if (sssp->ulongtab != NULL)
  {
    sssp->exportptr.ulongtabsectionptr = sssp->ulongtab + sssp->bucketleftidx
                                                        + subbucketleft
                                                        - sssp->partoffset;
    sssp->exportptr.uinttabsectionptr = NULL;
  } else
  {
    gt_assert(sssp->uinttab != NULL);
    sssp->exportptr.uinttabsectionptr = sssp->uinttab + sssp->bucketleftidx
                                                      + subbucketleft
                                                      - sssp->partoffset;
    sssp->exportptr.ulongtabsectionptr = NULL;
  }
  sssp->currentexport = true;
  return &sssp->exportptr;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1fc945
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1fc90a
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,8), %rax
leaq (%rax,%rsi,8), %rdx
shlq $0x3, %rcx
subq %rcx, %rdx
leaq 0x18(%rdi), %rax
movq %rdx, 0x20(%rdi)
jmp 0x1fc932
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1fc94a
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,4), %rax
leaq (%rax,%rsi,4), %rax
shlq $0x2, %rcx
subq %rcx, %rax
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %rax
movq $0x0, (%rax)
movb $0x1, (%rdi)
addq $0x18, %rdi
movq %rdi, %rax
popq %rcx
retq
callq 0x7df27
callq 0x7deee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_export_done
void gt_suffixsortspace_export_done (GtSuffixsortspace *sssp)
{
  gt_assert(sssp != NULL);
  sssp->exportptr.ulongtabsectionptr = NULL;
  sssp->exportptr.uinttabsectionptr = NULL;
  sssp->currentexport = false;
}

// Assembly:
testq %rdi, %rdi
je 0x1fc95f
movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
retq
pushq %rax
callq 0x7df60
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_get
GtUword gt_suffixsortspace_get (const GtSuffixsortspace *sssp,
                                GtUword subbucketleft,
                                GtUword idx)
{
  gt_assert(sssp != NULL);
  return gt_suffixsortspace_getdirect(sssp, sssp->bucketleftidx
                                              + subbucketleft
                                              + idx
                                              - sssp->partoffset);
}

// Assembly:
testq %rdi, %rdi
je 0x1fc97d
addq %rsi, %rdx
addq 0x40(%rdi), %rdx
subq 0x38(%rdi), %rdx
movq %rdx, %rsi
jmp 0x1fc7ed
pushq %rax
callq 0x7df99
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_getptr_ulong
const GtUword *gt_suffixsortspace_getptr_ulong (const GtSuffixsortspace *sssp,
                                                GtUword subbucketleft)
{
  gt_assert(sssp != NULL);
  if (sssp->ulongtab != NULL)
  {
    return sssp->ulongtab + sssp->bucketleftidx + subbucketleft
                          - sssp->partoffset;
  } else
  {
    return NULL;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1fc9ac
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1fc9a9
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,8), %rax
leaq (%rax,%rsi,8), %rax
shlq $0x3, %rcx
subq %rcx, %rax
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x7dfd2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_getptr_uint32
const uint32_t *gt_suffixsortspace_getptr_uint32 (const GtSuffixsortspace *sssp,
                                                  GtUword subbucketleft)
{
  gt_assert(sssp != NULL);
  if (sssp->uinttab != NULL)
  {
    return sssp->uinttab + sssp->bucketleftidx + subbucketleft
                         - sssp->partoffset;
  } else
  {
    return NULL;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1fc9db
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1fc9d8
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,4), %rax
leaq (%rax,%rsi,4), %rax
shlq $0x2, %rcx
subq %rcx, %rax
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x7e00b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_set
void gt_suffixsortspace_set (GtSuffixsortspace *sssp,
                             GtUword subbucketleft,
                             GtUword idx,
                             GtUword value)
{
  GtUword updateindex;

  gt_assert(sssp != NULL);
  updateindex = sssp->bucketleftidx + subbucketleft + idx - sssp->partoffset;
  gt_assert (sssp->widthrelative2bucketleftidx  == 0 ||
             updateindex <
             sssp->bucketleftidx + sssp->widthrelative2bucketleftidx);
  gt_suffixsortspace_setdirect(sssp, updateindex,value);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1fca17
addq %rsi, %rdx
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rsi
addq %rax, %rdx
subq 0x38(%rdi), %rdx
testq %rsi, %rsi
sete %r8b
addq %rax, %rsi
cmpq %rsi, %rdx
setb %al
orb %r8b, %al
je 0x1fca1c
movq %rdx, %rsi
movq %rcx, %rdx
popq %rax
jmp 0x1fca21
callq 0x7e07d
callq 0x7e044
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_setdirect
static void gt_suffixsortspace_setdirect(GtSuffixsortspace *sssp,
                                         GtUword idx,
                                         GtUword value)
{
  gt_assert(sssp != NULL && idx <= sssp->maxindex && value <= sssp->maxvalue);
  if (value == 0)
  {
    sssp->longestidx.defined = true;
    sssp->longestidx.valueunsignedlong = sssp->partoffset + idx;
  }
  if (sssp->ulongtab != NULL)
  {
    sssp->ulongtab[idx] = value;
  } else
  {
    gt_assert (sssp->uinttab != NULL && value <= (GtUword) UINT_MAX);
    sssp->uinttab[idx] = (uint32_t) value;
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1fca6d
cmpq %rsi, 0x28(%rdi)
jb 0x1fca6d
cmpq %rdx, 0x30(%rdi)
jb 0x1fca6d
testq %rdx, %rdx
jne 0x1fca47
movb $0x1, 0x8(%rdi)
movq 0x38(%rdi), %rax
addq %rsi, %rax
movq %rax, 0x10(%rdi)
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1fca56
movq %rdx, (%rax,%rsi,8)
jmp 0x1fca6b
movq %rdx, %rax
shrq $0x20, %rax
jne 0x1fca72
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1fca72
movl %edx, (%rax,%rsi,4)
popq %rax
retq
callq 0x7e0ef
callq 0x7e0b6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_bucketrange_set
void gt_suffixsortspace_bucketrange_set(GtSuffixsortspace *sssp,
                                        GtUword bucketleftidx,
                                        GtUword widthrelative2bucketleftidx)
{
  gt_assert(sssp != NULL && (sssp->bucketleftidx == bucketleftidx ||
                             !sssp->currentexport));
  sssp->bucketleftidx = bucketleftidx;
  sssp->widthrelative2bucketleftidx = widthrelative2bucketleftidx;
}

// Assembly:
testq %rdi, %rdi
je 0x1fcb1d
cmpq %rsi, 0x40(%rdi)
je 0x1fcb14
cmpb $0x1, (%rdi)
je 0x1fcb1d
movq %rsi, 0x40(%rdi)
movq %rdx, 0x48(%rdi)
retq
pushq %rax
callq 0x7e161
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_sortspace_delete
void gt_suffixsortspace_sortspace_delete (GtSuffixsortspace *sssp)
{
  gt_assert(sssp != NULL);
  gt_free(sssp->ulongtab);
  sssp->ulongtab = NULL;
  gt_free(sssp->uinttab);
  sssp->uinttab = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1fcb8d
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq 0x1be3fa(%rip), %r14    # 0x3baf58
movq %r14, %rsi
movl $0x19d, %edx            # imm = 0x19D
callq 0x1045eb
xorl %r15d, %r15d
movq %r15, 0x50(%rbx)
movq 0x58(%rbx), %rdi
movq %r14, %rsi
movl $0x19f, %edx            # imm = 0x19F
callq 0x1045eb
movq %r15, 0x58(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x7e1d3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_delete_cloned
void gt_suffixsortspace_delete_cloned(GtSuffixsortspace **sssp_tab,
                                      unsigned int parts)
{
  bool found = false;
  unsigned int p;

  gt_assert(sssp_tab != NULL && parts > 1U && sssp_tab[0]->clonenumber == 0);
  for (p = 1U; p < parts; p++)
  {
    GtSuffixsortspace *sssp = sssp_tab[p];

    gt_assert(sssp->clonenumber == p);
    if (!found && sssp->longestidx.defined)
    {
      GtUword zerotest;
      gt_assert(sssp->longestidx.valueunsignedlong >= sssp->partoffset);
      zerotest = sssp->longestidx.valueunsignedlong - sssp->partoffset;
      if ((sssp->ulongtab != NULL && sssp->ulongtab[zerotest] == 0) ||
          (sssp->uinttab != NULL && sssp->uinttab[zerotest] == 0))
      {
        sssp_tab[0]->longestidx.defined = true;
        sssp_tab[0]->longestidx.valueunsignedlong
          = sssp->longestidx.valueunsignedlong;
        found = true;
      }
    }
    gt_suffixsortspace_delete(sssp_tab[p],false);
    sssp_tab[p] = NULL;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1fcc48
cmpl $0x2, %esi
jb 0x1fcc48
movq %rdi, %rbx
movq (%rdi), %rax
cmpl $0x0, 0x4(%rax)
jne 0x1fcc48
movl %esi, %r14d
movl $0x1, %r15d
xorl %eax, %eax
movq (%rbx,%r15,8), %rdi
movl 0x4(%rdi), %ecx
cmpq %rcx, %r15
jne 0x1fcc3e
movb $0x1, %bpl
testb $0x1, %al
jne 0x1fcc1a
cmpb $0x1, 0x8(%rdi)
jne 0x1fcc0b
movq 0x10(%rdi), %rax
movq %rax, %rcx
subq 0x38(%rdi), %rcx
jb 0x1fcc43
movq 0x50(%rdi), %rdx
testq %rdx, %rdx
je 0x1fcbfc
cmpq $0x0, (%rdx,%rcx,8)
je 0x1fcc0f
movq 0x58(%rdi), %rdx
testq %rdx, %rdx
je 0x1fcc0b
cmpl $0x0, (%rdx,%rcx,4)
je 0x1fcc0f
xorl %ebp, %ebp
jmp 0x1fcc1a
movq (%rbx), %rcx
movb $0x1, 0x8(%rcx)
movq %rax, 0x10(%rcx)
xorl %esi, %esi
callq 0x1fc765
movq $0x0, (%rbx,%r15,8)
incq %r15
movl %ebp, %eax
cmpq %r15, %r14
jne 0x1fcbc6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x7e245
callq 0x7e27e
callq 0x7e20c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_to_file
void gt_suffixsortspace_to_file (FILE *outfpsuftab,
                                 const GtSuffixsortspace *sssp,
                                 GtUword numberofsuffixes)
{
  gt_assert(sssp != NULL);
  if (sssp->ulongtab != NULL)
  {
    gt_xfwrite((void *) sssp->ulongtab,sizeof (*sssp->ulongtab),
               (size_t) numberofsuffixes, outfpsuftab);
  } else
  {
    gt_assert(sssp->uinttab != NULL);
    gt_xfwrite((void *) sssp->uinttab,sizeof (*sssp->uinttab),
               (size_t) numberofsuffixes, outfpsuftab);
  }
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x1fcca5
movq %rdi, %rcx
movq 0x50(%rsi), %rdi
testq %rdi, %rdi
je 0x1fcc91
movl $0x8, %esi
jmp 0x1fcc9f
movq 0x58(%rsi), %rdi
testq %rdi, %rdi
je 0x1fccaa
movl $0x4, %esi
popq %rax
jmp 0x11f89c
callq 0x7e362
callq 0x7e329
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_compressed_to_file
void gt_suffixsortspace_compressed_to_file (const GtSuffixsortspace *sssp,
                                            GtBitbuffer *bb,
                                            GtUword numberofsuffixes)
{
  gt_assert(sssp != NULL);
  if (sssp->ulongtab != NULL)
  {
    gt_bitbuffer_write_ulongtab_FILE(bb,sssp->ulongtab,numberofsuffixes);
  } else
  {
    gt_assert (sssp->uinttab != NULL);
    gt_bitbuffer_write_uint32tab_FILE(bb,sssp->uinttab,numberofsuffixes);
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1fccdf
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x1fccca
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmp 0xd67ba
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x1fcce4
movq %rsi, %rdi
movq %rax, %rsi
popq %rax
jmp 0xd677e
callq 0x7e3d4
callq 0x7e39b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_SSSPbuf_new
GtSSSPbuf *gt_SSSPbuf_new(GtUword size)
{
  GtSSSPbuf *sssp_buf = gt_malloc(sizeof *sssp_buf);

  sssp_buf->size = size;
  sssp_buf->nextfree = 0;
  sssp_buf->overhang.start = sssp_buf->overhang.end = 0;
  return sssp_buf;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1be264(%rip), %rsi    # 0x3baf58
movl $0x20, %edi
movl $0x223, %edx            # imm = 0x223
callq 0x104226
movq %rbx, 0x10(%rax)
movq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_SSSPbuf_insertfullspecialrange
static GtUword gt_suffixsortspace_insertfullspecialrange(
                                                  GtSuffixsortspace *sssp,
                                                  GtReadmode readmode,
                                                  GtUword nextfree,
                                                  GtUword totallength,
                                                  GtUword leftpos,
                                                  GtUword rightpos)
{
  GtUword pos;

  gt_assert(leftpos < rightpos);
  if (GT_ISDIRREVERSE(readmode))
  {
    pos = rightpos - 1;
  } else
  {
    pos = leftpos;
  }
  while (true)
  {
    if (GT_ISDIRREVERSE(readmode))
    {
      gt_assert(pos < totallength);
      gt_suffixsortspace_setdirect(sssp,nextfree,
                                   GT_REVERSEPOS(totallength,pos));
      nextfree++;
      if (pos == leftpos)
      {
        break;
      }
      pos--;
    } else
    {
      gt_suffixsortspace_setdirect(sssp, nextfree, pos);
      nextfree++;
      if (pos == rightpos-1)
      {
        break;
      }
      pos++;
    }
  }
  return nextfree;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpq %r9, %r8
jae 0x1fcfd3
movq %r9, %rbx
movq %rcx, %r12
movl %esi, %ebp
movq %rdi, %r13
movq %rdx, 0x8(%rsp)
movq 0x18(%rdx), %r14
andl $-0x3, %ebp
decq %rbx
cmpl $0x1, %ebp
movq %r8, 0x10(%rsp)
movq %r8, %r15
cmoveq %rbx, %r15
cmpl $0x1, %ebp
jne 0x1fcf96
cmpq %r12, %r15
jae 0x1fcfce
movq %r15, %rdx
notq %rdx
addq %r12, %rdx
movq %r13, %rdi
movq %r14, %rsi
callq 0x1fca21
incq %r14
movq $-0x1, %rax
cmpq 0x10(%rsp), %r15
jne 0x1fcfb1
jmp 0x1fcfb6
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1fca21
incq %r14
movl $0x1, %eax
cmpq %rbx, %r15
je 0x1fcfb6
addq %rax, %r15
jmp 0x1fcf65
movq 0x8(%rsp), %rax
movq %r14, 0x18(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7e52a
callq 0x7e4f1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/sfx-suftaborder.c
// Function: gt_showentiresuftab
void gt_showentiresuftab(const GtEncseq *encseq,
                         GtReadmode readmode,
                         const GtSuffixsortspace *suffixsortspace,
                         GtUword subbucketleft,
                         GtUword depth)
{
  GtUword idx, pos, totallength = gt_encseq_total_length(encseq);

  for (idx = 0; idx <= totallength; idx++)
  {
    pos = gt_suffixsortspace_get(suffixsortspace,subbucketleft,idx);
    printf("suftab["GT_WU"]="GT_WU" ",idx,pos);
    gt_encseq_showatstartposwithdepth(stdout,encseq,readmode,pos,depth);
    printf("\n");
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
callq 0xe7b9c
movq %rax, %r13
xorl %ebx, %ebx
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %rbx, %rdx
callq 0x1fc965
movq %rax, %r14
leaq 0x1be5f5(%rip), %rdi    # 0x3bb77a
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
movq 0x2bbd3f(%rip), %rax    # 0x4b8ed8
movq (%rax), %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq 0x10(%rsp), %r8
callq 0xed8f5
movl $0xa, %edi
callq 0x17a20
incq %rbx
cmpq %r13, %rbx
jbe 0x1fd16b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/shu-encseq-gc.c
// Function: gt_encseq_get_rel_gc
double *gt_encseq_get_rel_gc(const GtEncseq *encseq,
                             GT_UNUSED GtError *err)
{
  double *gc_content;
  GtUword *gc_count_per_seq,
                max_unit,
                seq_idx = 0;
  bool is_mirrored_encseq;

  is_mirrored_encseq = gt_encseq_is_mirrored(encseq);
  if (is_mirrored_encseq)
  {
    max_unit = GT_DIV2(gt_encseq_num_of_sequences(encseq));
    gc_content = gt_calloc((size_t) GT_MULT2(max_unit), sizeof (double));
  }
  else
  {
    max_unit = gt_encseq_num_of_sequences(encseq);
    gc_content = gt_calloc((size_t) max_unit, sizeof (double));
  }

  gc_count_per_seq = gt_encseq_gc_count(encseq);
  for (seq_idx = 0; seq_idx < max_unit; seq_idx++) {
    calculate_rel_gc(encseq,
                     gc_content,
                     seq_idx,
                     gc_count_per_seq[seq_idx]);
  }
  if (is_mirrored_encseq)
  {
    GtUword double_max_unit = GT_MULT2(max_unit);
    for (seq_idx = 0; seq_idx < max_unit; seq_idx++)
    {
      gc_content[double_max_unit - seq_idx - 1] = gc_content[seq_idx];
    }
  }
  return gc_content;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xf6567
movl %eax, %ebp
movq %r14, %rdi
callq 0xe7bac
movq %rax, %rbx
testb %bpl, %bpl
je 0x1fd5ad
movq %rbx, %rdi
andq $-0x2, %rdi
leaq 0x1be2aa(%rip), %rdx    # 0x3bb826
movl $0x8, %esi
movl $0x76, %ecx
callq 0x10436a
movq %rax, %r15
movq %r14, %rdi
callq 0x1fd37c
cmpq $0x2, %rbx
jb 0x1fd6b4
movq %rax, %r12
movb %bpl, 0x7(%rsp)
shrq %rbx
jmp 0x1fd5e2
leaq 0x1be272(%rip), %rdx    # 0x3bb826
movl $0x8, %esi
movq %rbx, %rdi
movl $0x7b, %ecx
callq 0x10436a
movq %rax, %r15
movq %r14, %rdi
callq 0x1fd37c
testq %rbx, %rbx
je 0x1fd6b4
movq %rax, %r12
movb %bpl, 0x7(%rsp)
xorl %r13d, %r13d
movq (%r12,%r13,8), %rbp
movq %r14, %rdi
callq 0xe7bac
cmpq %r13, %rax
jbe 0x1fd6d5
movq %r14, %rdi
movq %r13, %rsi
callq 0xeb9d2
cmpq %rbp, %rax
jb 0x1fd6cb
movq %rbp, %xmm1
movq 0x14a2c5(%rip), %xmm2   # 0x3478e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x14a2c9(%rip), %xmm3   # 0x3478f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd %xmm0, (%r15,%r13,8)
xorpd %xmm1, %xmm1
callq 0x105c1c
cmpl $-0x1, %eax
je 0x1fd6d0
movsd (%r15,%r13,8), %xmm0
movsd 0x148bb2(%rip), %xmm1   # 0x346228
callq 0x105c1c
cmpl $0x1, %eax
je 0x1fd6c6
incq %r13
cmpq %r13, %rbx
jne 0x1fd5e5
cmpb $0x0, 0x7(%rsp)
je 0x1fd6b4
leaq -0x1(,%rbx,2), %rax
xorl %ecx, %ecx
movsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%r15,%rax,8)
incq %rcx
decq %rax
cmpq %rcx, %rbx
jne 0x1fd69d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7e8c6
callq 0x7e934
callq 0x7e8fd
callq 0x7e88f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/shu-genomediff.c
// Function: genomediff_print_table
static void genomediff_print_table(double **tab,
                                   GtShuUnitFileInfo *unit_info)
{
  GtUword i_idx, j_idx;

  for (i_idx = 0; i_idx < unit_info->num_of_genomes; i_idx++) {
    printf("# %s\t", gt_str_array_get(unit_info->genome_names, i_idx));
    for (j_idx = 0; j_idx < unit_info->num_of_genomes; j_idx++) {
      if (i_idx == j_idx)
        printf("%.6f\t",0.0);
      else
        printf("%f\t", tab[i_idx][j_idx]);
    }
    printf("\n");
  }
}

// Assembly:
cmpq $0x0, (%rsi)
je 0x1fe12e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1bd9e4(%rip), %r12    # 0x3bba9a
leaq 0x1bd9e3(%rip), %r13    # 0x3bbaa0
xorl %ebp, %ebp
movq 0x10(%rbx), %rdi
movq %rbp, %rsi
callq 0x11bfb3
leaq 0x1bdad5(%rip), %rdi    # 0x3bbba7
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
cmpq $0x0, (%rbx)
je 0x1fe10e
xorl %r15d, %r15d
cmpq %r15, %rbp
jne 0x1fe0f2
xorps %xmm0, %xmm0
movq %r12, %rdi
jmp 0x1fe0ff
movq (%r14,%rbp,8), %rax
movsd (%rax,%r15,8), %xmm0
movq %r13, %rdi
movb $0x1, %al
callq 0x17070
incq %r15
cmpq (%rbx), %r15
jb 0x1fe0e5
movl $0xa, %edi
callq 0x17a20
incq %rbp
cmpq (%rbx), %rbp
jb 0x1fe0bf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/shu_unitfile.c
// Function: gt_shu_unit_info_delete
void gt_shu_unit_info_delete(GtShuUnitFileInfo *unit_info) {
  if (unit_info != NULL) {
    gt_free(unit_info->map_files);
    gt_str_array_delete(unit_info->genome_names);
    gt_free(unit_info);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1fe854
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x1bd386(%rip), %r14    # 0x3bbbad
movq %r14, %rsi
movl $0xca, %edx
callq 0x1045eb
movq 0x10(%rbx), %rdi
callq 0x11c144
movq %rbx, %rdi
movq %r14, %rsi
movl $0xcc, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/shu_unitfile.c
// Function: gt_shu_unit_info_new
GtShuUnitFileInfo *gt_shu_unit_info_new(const GtEncseq *encseq)
{
  GtShuUnitFileInfo *unit_info = gt_malloc(sizeof (*unit_info));

  unit_info->map_files = NULL;
  unit_info->genome_names = NULL;
  unit_info->num_of_genomes = 0;
  unit_info->num_of_files = gt_encseq_num_of_files(encseq);
  unit_info->file_names = gt_encseq_filenames(encseq);
  unit_info->encseq = encseq;
  gt_shu_unit_info_files_as_units(unit_info);
  return unit_info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x1bd349(%rip), %rsi    # 0x3bbbad
movl $0x30, %edi
movl $0xdf, %edx
callq 0x104226
movq %rax, %rbx
xorl %r15d, %r15d
movq %r15, 0x20(%rax)
movq %r15, 0x10(%rax)
movq %r15, (%rax)
movq %r14, %rdi
callq 0xefbc9
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0xec2d5
movq %rax, 0x18(%rbx)
movq %r14, 0x28(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
callq 0x11be10
movq %rax, 0x10(%rbx)
cmpq %r15, 0x8(%rbx)
je 0x1fe8dd
xorl %r14d, %r14d
movq 0x10(%rbx), %r15
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x11bfee
movq %r15, %rdi
movq %rax, %rsi
callq 0x11bf79
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x1fe8b9
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/spaced-seeds.c
// Function: spse_initdfsconstinfo
static void spse_initdfsconstinfo(Limdfsconstinfo *mt,
                                  unsigned int alphasize,
                                  ...)
                                 /* Variable argument list is as follows:
                                    const GtUchar *pattern,
                                    Bitsequence seedbitvector,
                                    GtUword seedweight
                                 */
{
  va_list ap;
  SpseLimdfsconstinfo *mti = (SpseLimdfsconstinfo*) mt;

  va_start(ap,alphasize);
  mti->pattern = va_arg(ap, const GtUchar *);
  mti->seedbitvector = va_arg(ap, GtBitsequence);
  mti->seedweight = va_arg(ap, GtUword);
  va_end(ap);
}

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x1fe94a
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %rsi, -0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
movl $0x10, %eax
cmpq $0x29, %rax
jae 0x1fe9b9
movq -0x70(%rsp), %rcx
leal 0x8(%rax), %edx
movl %edx, -0x80(%rsp)
movq (%rcx,%rax), %rcx
movq %rcx, 0x10(%rdi)
cmpl $0x21, %eax
jae 0x1fe9ce
movq -0x70(%rsp), %rdx
movl $0x10, %ecx
addq $0x10, %rcx
movl %ecx, -0x80(%rsp)
movq 0x8(%rdx,%rax), %rdx
movq %rdx, (%rdi)
cmpl $0x18, %eax
ja 0x1fe9e2
addq -0x70(%rsp), %rcx
addl $0x18, %eax
movl %eax, -0x80(%rsp)
jmp 0x1fe9f0
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, (%rdi)
movq -0x78(%rsp), %rcx
leaq 0x8(%rcx), %rax
movq %rax, -0x78(%rsp)
movq (%rcx), %rax
movq %rax, 0x8(%rdi)
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/spaced-seeds.c
// Function: spse_nextLimdfsstate
static void spse_nextLimdfsstate(const Limdfsconstinfo *mt,
                                 DECLAREPTRDFSSTATE(aliasoutcol),
                                 GtUword currentdepth,
                                 GtUchar currentchar,
                                 GT_UNUSED const DECLAREPTRDFSSTATE(aliasincol))
{
  SpseLimdfsstate *outcol = (SpseLimdfsstate *) aliasoutcol;
#ifndef NDEBUG
  const SpseLimdfsstate *incol = (const SpseLimdfsstate *) aliasincol;
#endif
  SpseLimdfsconstinfo *mti = (SpseLimdfsconstinfo*) mt;

  gt_assert(GT_ISNOTSPECIAL(currentchar));
  gt_assert(currentdepth > 0);
  gt_assert(incol->pathmatches);

  outcol->pathmatches = setpathmatch(mti->seedbitvector,
                                     mti->pattern,
                                     currentdepth,
                                     currentchar);
}

// Assembly:
pushq %rax
movl %ecx, %eax
cmpb $-0x2, %al
jae 0x1fea86
testq %rdx, %rdx
je 0x1fea8b
cmpb $0x0, (%r8)
je 0x1fea90
movq (%rdi), %r8
decq %rdx
movl %edx, %ecx
shlq %cl, %r8
movb $0x1, %cl
testq %r8, %r8
jns 0x1fea82
movq 0x10(%rdi), %rcx
cmpb %al, (%rcx,%rdx)
sete %cl
movb %cl, (%rsi)
popq %rax
retq
callq 0x7ece4
callq 0x7ed56
callq 0x7ed1d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/spaced-seeds.c
// Function: spse_inplacenextLimdfsstate
static void spse_inplacenextLimdfsstate(const Limdfsconstinfo *mt,
                                        DECLAREPTRDFSSTATE(aliascol),
                                        GtUword currentdepth,
                                        GtUchar currentchar)
{
  SpseLimdfsstate *col = (SpseLimdfsstate *) aliascol;
  const SpseLimdfsconstinfo *mti = (const SpseLimdfsconstinfo*) mt;

  gt_assert(GT_ISNOTSPECIAL(currentchar));
  gt_assert(currentdepth > 0);
  col->pathmatches = setpathmatch(mti->seedbitvector,
                                  mti->pattern,
                                  currentdepth,
                                  currentchar);
}

// Assembly:
pushq %rax
movl %ecx, %eax
cmpb $-0x2, %al
jae 0x1feac1
testq %rdx, %rdx
je 0x1feac6
movq (%rdi), %r8
decq %rdx
movl %edx, %ecx
shlq %cl, %r8
movb $0x1, %cl
testq %r8, %r8
jns 0x1feabd
movq 0x10(%rdi), %rcx
cmpb %al, (%rcx,%rdx)
sete %cl
movb %cl, (%rsi)
popq %rax
retq
callq 0x7ed8f
callq 0x7edc8
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/spmsuftab.c
// Function: gt_spmsuftab_new
GtSpmsuftab *gt_spmsuftab_new(GtUword numofentries,
                              GtUword maxvalue,
                              unsigned int bitsforseqnumrelpos,
                              GtLogger *logger)
{
  GtSpmsuftab *spmsuftab;
  unsigned int bitsforpositions;
  GtUword required;

  spmsuftab = gt_malloc(sizeof (*spmsuftab));
  required = (GtUword) gt_spmsuftab_requiredspace(numofentries,
                                                        maxvalue,
                                                        bitsforseqnumrelpos);
  bitsforpositions = gt_determinebitspervalue(maxvalue);
  if (bitsforpositions < bitsforseqnumrelpos)
  {
    gt_logger_log(logger,"use "GT_WU" bitpackarray-entries for all positions "
                         "(%u bits each,"GT_WU" bytes total)",
                         numofentries,bitsforpositions,required);
    spmsuftab->bitpackarray
      = gt_compact_ulong_store_new(numofentries,bitsforpositions);
    spmsuftab->usebitsforpositions = true;
    spmsuftab->maxvalue = maxvalue;
  } else
  {
    gt_logger_log(logger,"use "GT_WU" bitpackarray-entries for all "
                  "seqnum/relpos-pairs (%u bits each,"GT_WU" bytes total)",
                  numofentries,bitsforseqnumrelpos,required);
    spmsuftab->bitpackarray
      = gt_compact_ulong_store_new(numofentries,bitsforseqnumrelpos);
    spmsuftab->usebitsforpositions = false;
    spmsuftab->maxvalue = (1UL << bitsforseqnumrelpos) - 1;
  }
  spmsuftab->partoffset = 0;
  spmsuftab->numofentries = numofentries;
  return spmsuftab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1bd297(%rip), %rsi    # 0x3bbd81
movl $0x28, %edi
movl $0x20, %edx
callq 0x104226
movq %rax, %r14
movq %r15, %rdi
callq 0x105e91
cmpl %ebp, %eax
cmovael %ebp, %eax
movq %rbx, %rdi
movl %eax, %esi
callq 0xe3bc2
movq %rax, %r13
addq $0x28, %r13
movq %r15, %rdi
callq 0x105e91
cmpl %ebp, %eax
jae 0x1feb53
movl %eax, %r12d
leaq 0x1bd267(%rip), %rsi    # 0x3bbd97
movq (%rsp), %rdi
movq %rbx, %rdx
movl %eax, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x103fe1
movq %rbx, %rdi
movl %r12d, %esi
callq 0xe3b18
movb $0x1, %r12b
jmp 0x1feb89
leaq 0x1bd28b(%rip), %rsi    # 0x3bbde5
xorl %r12d, %r12d
movq (%rsp), %rdi
movq %rbx, %rdx
movl %ebp, %ecx
movq %r13, %r8
xorl %eax, %eax
callq 0x103fe1
movq %rbx, %rdi
movl %ebp, %esi
callq 0xe3b18
movq $-0x1, %r15
movl %ebp, %ecx
shlq %cl, %r15
notq %r15
movq %rax, 0x20(%r14)
movb %r12b, 0x18(%r14)
movq %r15, 0x10(%r14)
movq $0x0, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/spmsuftab.c
// Function: gt_spmsuftab_requiredspace
size_t gt_spmsuftab_requiredspace(GtUword numofentries,
                                  GtUword maxvalue,
                                  unsigned int bitsforseqnumrelpos)
{
  unsigned int bitsforpositions = gt_determinebitspervalue(maxvalue);

  return sizeof (GtSpmsuftab) +
         gt_compact_ulong_store_size(numofentries,
                                     GT_MIN(bitsforpositions,
                                            bitsforseqnumrelpos));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x105e91
cmpl %ebx, %eax
cmovbl %eax, %ebx
movq %r14, %rdi
movl %ebx, %esi
callq 0xe3bc2
addq $0x28, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq