LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-apfxlen.c
// Function: gt_recommendedprefixlength
unsigned int gt_recommendedprefixlength(unsigned int numofchars,
                                        GtUword totallength,
                                        double recommendedmultiplier,
                                        bool withspecialsuffixes)
{
  unsigned int prefixlength;

  prefixlength = prefixlengthwithmaxspace(numofchars,totallength,
                                          recommendedmultiplier,
                                          totallength+1,
                                          withspecialsuffixes);
  if (prefixlength == 0)
  {
    return 1U;
  } else
  {
    unsigned int mbp = gt_maxbasepower(numofchars);
    if (mbp >= 1U)
    {
      return GT_MIN(mbp,prefixlength);
    } else
    {
      return prefixlength;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movl %edi, %ebx
movq %rsi, %xmm0
punpckldq 0x1643d2(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1643da(%rip), %xmm0   # 0x3508f0
incq %r14
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movzbl %dl, %ebp
leal 0x2(%r15), %esi
movl %ebx, %edi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x193660
movq %rax, %xmm0
punpckldq 0x16438f(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x164397(%rip), %xmm0   # 0x3508f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd 0x8(%rsp), %xmm1
incl %r15d
ucomisd 0x10(%rsp), %xmm1
jbe 0x1ec534
testl %r15d, %r15d
je 0x1ec595
movl %ebx, %edi
callq 0x1bed24
movl %eax, %ecx
cmpl %r15d, %eax
movl %r15d, %eax
cmovbl %ecx, %eax
testl %ecx, %ecx
cmovel %r15d, %eax
jmp 0x1ec59a
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-apfxlen.c
// Function: gt_checkprefixlength
int gt_checkprefixlength(unsigned int maxprefixlen,
                      unsigned int prefixlength,
                      GtError *err)
{
  gt_error_check(err);
  if (maxprefixlen < prefixlength)
  {
    gt_error_set(err,"prefix length %u is too large, maximal prefix length "
                      "for this input size and alphabet size is %u",
                      prefixlength,
                      maxprefixlen);
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %ebx
testq %rdx, %rdx
je 0x1ec701
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1ec726
xorl %eax, %eax
cmpl %ebp, %ebx
jae 0x1ec721
leaq 0x1d24f7(%rip), %rsi    # 0x3bec05
movq %r14, %rdi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
callq 0x771f5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_size_of_sort_workspace
size_t gt_size_of_sort_workspace (const Sfxstrategy *sfxstrategy)
{
  size_t sumsize = 0;

  if (!sfxstrategy->cmpcharbychar)
  {
    sumsize += sizeof (GtCountingsortinfo) * sfxstrategy->maxcountingsort;
    if (sfxstrategy->maxwidthrealmedian >= MINMEDIANOF9WIDTH)
    {
      sumsize += sizeof (GtMedianinfo) * sfxstrategy->maxwidthrealmedian;
    }
  }
  sumsize += gt_blindtrie_size(sfxstrategy->maxbltriesort);
  return sumsize;
}

// Assembly:
pushq %rbx
cmpb $0x0, 0x2c(%rdi)
je 0x1ec77b
xorl %ebx, %ebx
jmp 0x1ec793
movq (%rdi), %rax
movq 0x18(%rdi), %rbx
shlq $0x4, %rbx
cmpq $0x1f, %rax
jb 0x1ec793
shlq $0x5, %rax
addq %rax, %rbx
movq 0x10(%rdi), %rdi
callq 0x1ef8d0
addq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_bentsedgresources_addlcpinfo
static void gt_bentsedgresources_addlcpinfo(GtBentsedgresources *bsr,
                                            GtOutlcpinfo *outlcpinfo,
                                            const GtBcktab *bcktab)
{
  if (outlcpinfo != NULL)
  {
    bsr->tableoflcpvalues = gt_Outlcpinfo_resizereservoir(outlcpinfo,bcktab);
    if (bsr->srsw != NULL)
    {
      gt_shortreadsort_assigntableoflcpvalues(bsr->srsw,bsr->tableoflcpvalues);
    }
  }
}

// Assembly:
testq %rsi, %rsi
je 0x1eccad
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x1f6782
movq %rax, 0x38(%rbx)
movq 0x2e0(%rbx), %rdi
testq %rdi, %rdi
popq %rbx
je 0x1eccad
movq %rax, %rsi
jmp 0x1fec43
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: bentsedgresources_delete
static void bentsedgresources_delete(GtBentsedgresources *bsr, GtLogger *logger)
{
  gt_free(bsr->countingsortinfo);
  bsr->countingsortinfo = NULL;
  gt_free(bsr->medianinfospace);
  bsr->medianinfospace = NULL;
  gt_shortreadsort_delete(bsr->srsw);
  bsr->srsw = NULL;
  gt_blindtrie_delete(bsr->blindtrie);
  gt_encseq_reader_delete(bsr->esr1);
  gt_encseq_reader_delete(bsr->esr2);
  gt_free(bsr->equalwithprevious);
  GT_FREEARRAY(&bsr->mkvauxstack,GtMKVstack);
  gt_radixsort_str_delete(bsr->rsi);
  gt_logger_log(logger,"countinsertionsort="GT_WU"",bsr->countinsertionsort);
  gt_logger_log(logger,"countbltriesort="GT_WU"",bsr->countbltriesort);
  gt_logger_log(logger,"countcountingsort="GT_WU"",bsr->countcountingsort);
  gt_logger_log(logger,"countshortreadsort="GT_WU"",bsr->countshortreadsort);
  gt_logger_log(logger,"countradixsort="GT_WU"",bsr->countradixsort);
  gt_logger_log(logger,"counttqsort="GT_WU"",bsr->counttqsort);
  gt_free(bsr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2d8(%rdi), %rdi
leaq 0x1d09fb(%rip), %r15    # 0x3bed40
movq %r15, %rsi
movl $0x5e4, %edx            # imm = 0x5E4
callq 0x109670
xorl %r12d, %r12d
movq %r12, 0x2d8(%rbx)
movq 0x2d0(%rbx), %rdi
movq %r15, %rsi
movl $0x5e6, %edx            # imm = 0x5E6
callq 0x109670
movq %r12, 0x2d0(%rbx)
movq 0x2e0(%rbx), %rdi
callq 0x1feba4
movq %r12, 0x2e0(%rbx)
movq 0x2c8(%rbx), %rdi
callq 0x1ef909
movq 0x8(%rbx), %rdi
callq 0xed7bf
movq 0x10(%rbx), %rdi
callq 0xed7bf
movq 0x2c0(%rbx), %rdi
movq %r15, %rsi
movl $0x5ed, %edx            # imm = 0x5ED
callq 0x109670
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1ee3e9
leaq 0x20(%rbx), %r15
leaq 0x1d0970(%rip), %rsi    # 0x3bed40
movl $0x5ee, %edx            # imm = 0x5EE
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0x2f0(%rbx), %rdi
callq 0x32ab9a
movq 0x68(%rbx), %rdx
leaq 0x1d0d37(%rip), %rsi    # 0x3bf137
movq %r14, %rdi
xorl %eax, %eax
callq 0x10906e
movq 0x90(%rbx), %rdx
leaq 0x1d0d36(%rip), %rsi    # 0x3bf14e
movq %r14, %rdi
xorl %eax, %eax
callq 0x10906e
movq 0x88(%rbx), %rdx
leaq 0x1d0d32(%rip), %rsi    # 0x3bf162
movq %r14, %rdi
xorl %eax, %eax
callq 0x10906e
movq 0x78(%rbx), %rdx
leaq 0x1d0d33(%rip), %rsi    # 0x3bf178
movq %r14, %rdi
xorl %eax, %eax
callq 0x10906e
movq 0x80(%rbx), %rdx
leaq 0x1d0d32(%rip), %rsi    # 0x3bf18f
movq %r14, %rdi
xorl %eax, %eax
callq 0x10906e
movq 0x70(%rbx), %rdx
leaq 0x1d0d30(%rip), %rsi    # 0x3bf1a2
movq %r14, %rdi
xorl %eax, %eax
callq 0x10906e
leaq 0x1d08bd(%rip), %rsi    # 0x3bed40
movq %rbx, %rdi
movl $0x5f6, %edx            # imm = 0x5F6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_sortallsuffixesfromstart
void gt_sortallsuffixesfromstart(GtSuffixsortspace *suffixsortspace,
                                 GtUword numberofsuffixes,
                                 const GtEncseq *encseq,
                                 GtReadmode readmode,
                                 GtOutlcpinfo *outlcpinfo,
                                 unsigned int sortmaxdepth,
                                 const Sfxstrategy *sfxstrategy,
                                 GtProcessunsortedsuffixrange
                                   processunsortedsuffixrange,
                                 void *processunsortedsuffixrangeinfo,
                                 GtLogger *logger)
{
  if (numberofsuffixes > 1UL)
  {
    GtBentsedgresources *bsr = bentsedgresources_new(suffixsortspace,
                                                     encseq,
                                                     readmode,
                                                     0,
                                                     NULL,
                                                     sortmaxdepth,
                                                     sfxstrategy,
                                                     outlcpinfo != NULL
                                                       ? true : false);
    gt_bentsedgresources_addlcpinfo(bsr,outlcpinfo,NULL);
    bsr->processunsortedsuffixrange = processunsortedsuffixrange;
    bsr->processunsortedsuffixrangeinfo = processunsortedsuffixrangeinfo;
    gt_sort_bentleysedgewick(bsr,0,numberofsuffixes,0);
    bentsedgresources_delete(bsr, logger);
  }
}

// Assembly:
cmpq $0x2, %rsi
jb 0x1ee527
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rsi, %rbx
movq 0x58(%rsp), %r14
movq 0x50(%rsp), %r13
movq 0x48(%rsp), %rbp
xorl %eax, %eax
testq %r8, %r8
setne %al
movq %rdx, %rsi
movl %ecx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq 0x48(%rsp)
callq 0x1ec92e
addq $0x10, %rsp
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1ecc80
movq %rbp, 0x50(%r12)
movq %r13, 0x58(%r12)
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x1eccae
movq %r12, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ee329
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: medianof3cmpcharbychar
static GtUword medianof3cmpcharbychar(const GtBentsedgresources *bsr,
                                            GtUword subbucketleft,
                                            GtUword depth,
                                            GtUword a,
                                            GtUword b,
                                            GtUword c)
{
  GtUword vala, valb, valc, cptr;
  GtUchar tmpavar, tmpbvar;

  CMPCHARBYCHARPTR2INT(vala,subbucketleft,tmpavar,a);
  CMPCHARBYCHARPTR2INT(valb,subbucketleft,tmpbvar,b);
  if (vala == valb)
  {
    return a;
  }
  CMPCHARBYCHARPTR2INT(valc,subbucketleft,tmpavar,c);
  if (vala == valc || valb == valc)
  {
    return c;
  }
  return vala < valb ?
        (valb < valc ? b : (vala < valc ? c : a))
      : (valb > valc ? b : (vala < valc ? a : c));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r13
movq 0x48(%rdi), %rdi
movq %rcx, 0x10(%rsp)
movq %rcx, %rdx
callq 0x206063
movq %rax, %r12
addq %rbp, %r12
cmpq 0xb0(%r13), %r12
jae 0x1ef4ce
movq (%r13), %rdi
movl 0x18(%r13), %edx
movq %r12, %rsi
callq 0xec1f8
cmpb $-0x3, %al
ja 0x1ef4ce
movzbl %al, %r12d
jmp 0x1ef4d5
addq $0x100, %r12            # imm = 0x100
movq 0x48(%r13), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x206063
movq %rax, %r15
addq %rbp, %r15
cmpq 0xb0(%r13), %r15
jae 0x1ef50d
movq (%r13), %rdi
movl 0x18(%r13), %edx
movq %r15, %rsi
callq 0xec1f8
cmpb $-0x3, %al
ja 0x1ef50d
movzbl %al, %r15d
jmp 0x1ef514
addq $0x100, %r15            # imm = 0x100
cmpq %r15, %r12
jne 0x1ef520
movq 0x10(%rsp), %r14
jmp 0x1ef589
movq 0x48(%r13), %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
callq 0x206063
movq %rax, %rbx
addq %rbp, %rbx
cmpq 0xb0(%r13), %rbx
jae 0x1ef559
movq (%r13), %rdi
movl 0x18(%r13), %edx
movq %rbx, %rsi
callq 0xec1f8
cmpb $-0x3, %al
ja 0x1ef559
movzbl %al, %ebx
jmp 0x1ef560
addq $0x100, %rbx            # imm = 0x100
cmpq %rbx, %r12
je 0x1ef584
cmpq %rbx, %r15
je 0x1ef584
cmpq %r15, %r12
jae 0x1ef59b
cmpq %rbx, %r15
jb 0x1ef589
cmpq %rbx, %r12
movq 0x10(%rsp), %r14
cmovbq 0x8(%rsp), %r14
jmp 0x1ef589
movq 0x8(%rsp), %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rbx, %r15
ja 0x1ef589
cmpq %rbx, %r12
movq 0x8(%rsp), %r14
cmovbq 0x10(%rsp), %r14
jmp 0x1ef589
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: medianof3
static GtUword medianof3(const GtBentsedgresources *bsr,
                               GtUword subbucketleft,
                               GtUword depth,
                               GtUword a,
                               GtUword b,
                               GtUword c)
{
  GtSfxcmp vala, valb, valc;
  GtCommonunits commonunits;
  int retvalavalb, retvalavalc, retvalbvalc;

  PTR2INT(vala,subbucketleft,a);
  PTR2INT(valb,subbucketleft,b);
  Sfxdocompare(&commonunits,vala,valb);
  if (GtSfxcmpEQUAL(vala,valb))
  {
    return a;
  }
  PTR2INT(valc,subbucketleft,c);
  Sfxdocompare(&commonunits,vala,valc);
  if (GtSfxcmpEQUAL(vala,valc))
  {
    return c;
  }
  Sfxdocompare(&commonunits,valb,valc);
  if (GtSfxcmpEQUAL(valb,valc))
  {
    return c;
  }
  return GtSfxcmpSMALLER(vala,valb) ?
        (GtSfxcmpSMALLER(valb,valc) ? b : (GtSfxcmpSMALLER(vala,valc) ? c : a))
      : (GtSfxcmpGREATER(valb,valc) ? b : (GtSfxcmpSMALLER(vala,valc) ? a : c));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
movq 0x48(%rdi), %rdi
movq %rcx, %rdx
callq 0x206063
movq %rax, 0x50(%rsp)
addq %r13, %rax
cmpq 0xb0(%r12), %rax
jae 0x1ef60d
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl 0x18(%r12), %ecx
leaq 0x40(%rsp), %rdi
movq %rax, %r8
callq 0xf1097
jmp 0x1ef61e
movq $0x0, 0x40(%rsp)
movl $0x0, 0x48(%rsp)
movq 0x48(%r12), %rdi
movq %rbp, %rsi
movq %r14, %rdx
callq 0x206063
movq %rax, 0x38(%rsp)
addq %r13, %rax
cmpq 0xb0(%r12), %rax
jae 0x1ef65d
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl 0x18(%r12), %ecx
leaq 0x28(%rsp), %rdi
movq %rax, %r8
callq 0xf1097
jmp 0x1ef66e
movq $0x0, 0x28(%rsp)
movl $0x0, 0x30(%rsp)
movzbl 0x1c(%r12), %edi
movzbl 0x1d(%r12), %esi
leaq 0x58(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0xf1748
testl %eax, %eax
je 0x1ef75c
movl %eax, %ebx
movq 0x48(%r12), %rdi
movq %rbp, %rsi
movq 0x8(%rsp), %rdx
callq 0x206063
movq %rax, 0x20(%rsp)
addq %rax, %r13
cmpq 0xb0(%r12), %r13
jae 0x1ef6d9
movq (%r12), %rdx
movq 0x8(%r12), %rsi
movl 0x18(%r12), %ecx
leaq 0x10(%rsp), %rdi
movq %r13, %r8
callq 0xf1097
jmp 0x1ef6ea
movq $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movzbl 0x1c(%r12), %edi
movzbl 0x1d(%r12), %esi
leaq 0x58(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0xf1748
testl %eax, %eax
je 0x1ef749
movl %eax, %ebp
movzbl 0x1c(%r12), %edi
movzbl 0x1d(%r12), %esi
leaq 0x58(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0xf1748
testl %eax, %eax
je 0x1ef749
testl %ebx, %ebx
js 0x1ef750
testl %eax, %eax
jg 0x1ef75f
testl %ebp, %ebp
movq 0x8(%rsp), %r14
cmovsq %r15, %r14
jmp 0x1ef75f
movq 0x8(%rsp), %r14
jmp 0x1ef75f
testl %eax, %eax
js 0x1ef75f
testl %ebp, %ebp
cmovsq 0x8(%rsp), %r15
movq %r15, %r14
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: gt_blindtrie_resize
void gt_blindtrie_resize(GtBlindtrie *blindtrie,unsigned int maxnumofnodes)
{
  gt_assert(maxnumofnodes > 0);
  if (blindtrie->allocatedBlindtrienode > maxnumofnodes)
  {
    blindtrie->allocatedBlindtrienode = maxnumofnodes;
    blindtrie->spaceBlindtrienode
      = gt_realloc(blindtrie->spaceBlindtrienode,
                   sizeof (*blindtrie->spaceBlindtrienode) *
                   blindtrie->allocatedBlindtrienode);
  }
}

// Assembly:
pushq %rbx
testl %esi, %esi
je 0x1ef8cb
movq %rdi, %rbx
cmpl %esi, (%rdi)
jbe 0x1ef8c9
movl %esi, (%rbx)
movq 0x8(%rbx), %rdi
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
leaq 0x1cfa83(%rip), %rdx    # 0x3bf33e
movl $0x3c2, %ecx            # imm = 0x3C2
callq 0x1094e6
movq %rax, 0x8(%rbx)
popq %rbx
retq
callq 0x77d2c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: gt_blindtrie_delete
void gt_blindtrie_delete(GtBlindtrie *blindtrie)
{
  if (blindtrie == NULL)
  {
    return;
  }
  gt_Viatwobitkeyvalues_delete(blindtrie->vtk1);
  gt_Viatwobitkeyvalues_delete(blindtrie->vtk2);
  gt_free(blindtrie->spaceBlindtrienode);
  GT_FREEARRAY(&blindtrie->overflowsuffixes, GtUword);
  GT_FREEARRAY(&blindtrie->stack, GtBlindtriesnodeptr);
  gt_free(blindtrie);
}

// Assembly:
testq %rdi, %rdi
je 0x1ef9bb
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
callq 0xf1a70
movq 0x88(%rbx), %rdi
callq 0xf1a70
movq 0x8(%rbx), %rdi
leaq 0x1cfa02(%rip), %rsi    # 0x3bf33e
movl $0x3e6, %edx            # imm = 0x3E6
callq 0x109670
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x1ef973
leaq 0x28(%rbx), %r14
leaq 0x1cf9e4(%rip), %rsi    # 0x3bf33e
movl $0x3e7, %edx            # imm = 0x3E7
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1ef9a0
leaq 0x10(%rbx), %r14
leaq 0x1cf9b7(%rip), %rsi    # 0x3bf33e
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x1cf997(%rip), %rsi    # 0x3bf33e
movq %rbx, %rdi
movl $0x3e9, %edx            # imm = 0x3E9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_makeroot
static void blindtrie_makeroot(GtBlindtrie *blindtrie,
                               GtUword currentstartpos,
                               GtUword currenttwobitencodingstoppos)
{
  GtBlindtriesymbol firstchar;

  gt_assert(blindtrie->nextfreeBlindtrienode == GT_BLINDTRIE_ROOTIDX);
  (void) blindtrie_newnode(blindtrie);
  blindtrie_firstchar_set(blindtrie,GT_BLINDTRIE_ROOTIDX,
                          false,0); /* firstchar of root will never be used */
  blindtrie_setdepth(blindtrie,GT_BLINDTRIE_ROOTIDX,0);
  /*blindtrie_rightsibling_set(blindtrie,root,GT_BLINDTRIE_REFNULL); */
  if (blindtrie_isleftofboundary(blindtrie,currentstartpos,0))
  {
    /* Random access */
    firstchar = (GtBlindtriesymbol)
                gt_encseq_get_encoded_char(blindtrie->encseq,
                                           currentstartpos,
                                           blindtrie->readmode);
    if (GT_BLINDTRIECHAR_GT_ISSPECIAL(firstchar))
    {
      firstchar = GT_UNIQUEINT(currentstartpos);
    }
    if (currenttwobitencodingstoppos == ULONG_MAX)
    {
      currenttwobitencodingstoppos
        = blindtrie_currenttwobitencodingstoppos_get(blindtrie,currentstartpos);
    }
  } else
  {
    firstchar = GT_UNIQUEINT(currentstartpos);
    currenttwobitencodingstoppos = GT_BLTRIESTOPPOSUNDEF(blindtrie);
  }
  blindtrie_firstchild_set(blindtrie,GT_BLINDTRIE_ROOTIDX,
                           blindtrie_newleaf(blindtrie,currentstartpos,
                                             currenttwobitencodingstoppos,
                                             firstchar,GT_BLINDTRIE_REFNULL));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x4(%rdi)
jne 0x1f027d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1f0c43
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1f0dd1
movq 0x8(%rbx), %rax
movq $0x0, (%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1f0c93
movq 0x70(%rbx), %rax
testq %rax, %rax
je 0x1f0209
addq %r14, %rax
movq 0x60(%rbx), %rcx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
jmp 0x1f020d
movq 0x60(%rbx), %rax
cmpq %r14, %rax
jbe 0x1f0247
movq 0x40(%rbx), %rdi
movl 0x58(%rbx), %edx
movq %r14, %rsi
callq 0xec1f8
movzbl %al, %eax
leaq 0x100(%r14), %r12
cmpb $-0x2, %al
cmovbq %rax, %r12
cmpq $-0x1, %r15
jne 0x1f0252
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f0282
movq %rax, %r15
jmp 0x1f0252
leaq 0x100(%r14), %r12
movq 0x60(%rbx), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
callq 0x1f0ced
movq %rbx, %rdi
xorl %esi, %esi
movl %eax, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1f0cc1
callq 0x7807b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_currenttwobitencodingstoppos_get
static GtUword blindtrie_currenttwobitencodingstoppos_get(
                                     const GtBlindtrie *blindtrie,
                                     GtUword currentstartpos)
{
  if (!blindtrie->cmpcharbychar &&
      blindtrie->has_twobitencoding_stoppos_support)
  {
    gt_encseq_reader_reinit_with_readmode(blindtrie->esr1,blindtrie->encseq,
                                          blindtrie->readmode,
                                          currentstartpos);
    return gt_getnexttwobitencodingstoppos(GT_ISDIRREVERSE(blindtrie->readmode)
                                           ? false : true,blindtrie->esr1);
  }
  return GT_BLTRIESTOPPOSUNDEF(blindtrie);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x78(%rdi)
jne 0x1f02be
cmpb $0x1, 0x7a(%rbx)
jne 0x1f02be
movq %rsi, %rcx
movq 0x40(%rbx), %rsi
movq 0x48(%rbx), %rdi
movl 0x58(%rbx), %edx
callq 0xed48e
movl 0x58(%rbx), %eax
andl $-0x3, %eax
xorl %edi, %edi
cmpl $0x1, %eax
setne %dil
movq 0x48(%rbx), %rsi
popq %rbx
jmp 0xf0eda
movq 0x60(%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_findsplitnode
static GtBlindtriesnodeptr blindtrie_findsplitnode(const GtBlindtrie *blindtrie,
                                                GtUword lcp)
{
  GtBlindtriesnodeptr currentnode;
  GtUword stackidx;

  currentnode = GT_BLINDTRIE_ROOTIDX;
  for (stackidx=0;stackidx<blindtrie->stack.nextfreeGtBlindtriesnodeptr;
       stackidx++)
  {
    currentnode = blindtrie->stack.spaceGtBlindtriesnodeptr[stackidx];
    if (blindtrie_isleaf(blindtrie,currentnode) ||
        blindtrie_getdepth(blindtrie,currentnode) >= lcp)
    {
      break;
    }
  }
  return currentnode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x20(%rdi)
je 0x1f08f3
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movl (%rax,%r15,4), %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x1f04d3
testb %al, %al
jne 0x1f08f5
movq %r14, %rdi
movl %ebp, %esi
callq 0x1f0bac
cmpq %rbx, %rax
jae 0x1f08f5
incq %r15
cmpq 0x20(%r14), %r15
jb 0x1f08c3
jmp 0x1f08f5
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_newnode
static GtBlindtriesnodeptr blindtrie_newnode(GtBlindtrie *blindtrie)
{
  if (blindtrie->nextfreeBlindtrienode >= blindtrie->allocatedBlindtrienode)
  {
    gt_assert(blindtrie->nodenumberincrement >= 1U);
    gt_assert(blindtrie->allocatedBlindtrienode +
              blindtrie->nodenumberincrement <=
              (1U << GT_BLINDTRIE_BITSFORRIGHTSIBLING) - 1);
    blindtrie->allocatedBlindtrienode += blindtrie->nodenumberincrement;
    blindtrie->spaceBlindtrienode
      = gt_realloc(blindtrie->spaceBlindtrienode,
                   sizeof (*blindtrie->spaceBlindtrienode) *
                          blindtrie->allocatedBlindtrienode);
  }
  return blindtrie->nextfreeBlindtrienode++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
cmpl %ecx, 0x4(%rdi)
jb 0x1f0c7e
movl 0x7c(%rbx), %eax
testl %eax, %eax
je 0x1f0c89
addl %ecx, %eax
js 0x1f0c8e
movl %eax, (%rbx)
movq 0x8(%rbx), %rdi
movl %eax, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
leaq 0x1ce6ce(%rip), %rdx    # 0x3bf33e
movl $0x148, %ecx            # imm = 0x148
callq 0x1094e6
movq %rax, 0x8(%rbx)
movl 0x4(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x4(%rbx)
popq %rbx
retq
callq 0x7855d
callq 0x78524
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_newleaf
static GtBlindtriesnodeptr blindtrie_newleaf(GtBlindtrie *blindtrie,
                                          GtUword currentstartpos,
                                          GtUword
                                            currenttwobitencodingstoppos,
                                          GtBlindtriesymbol firstchar,
                                          GtBlindtriesnodeptr rightsibling)
{
  GtBlindtriesnodeptr newleaf;

  newleaf = blindtrie_newnode(blindtrie);
  blindtrie_firstchar_set(blindtrie,newleaf,true,firstchar);
  blindtrie_leafinfo_set(blindtrie,
                         newleaf,
                         currentstartpos,
                         currenttwobitencodingstoppos);
  blindtrie_rightsibling_set(blindtrie,newleaf,rightsibling);
  return newleaf;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x1f0c43
movl %eax, %ebp
movq %r14, %rdi
movl %eax, %esi
movl $0x1, %edx
callq 0x1f0dd1
movq 0x8(%r14), %rax
movl %ebp, %ecx
leaq (%rcx,%rcx,2), %rcx
movq %r13, (%rax,%rcx,8)
cmpl %ebp, 0x4(%r14)
jbe 0x1f0db8
leaq (%rax,%rcx,8), %rax
movq %r12, 0x8(%rax)
movq 0x60(%r14), %rcx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %r15, %rcx
je 0x1f0d98
movl 0x58(%r14), %edx
orl $0x2, %edx
cmpl $0x3, %edx
jne 0x1f0d7a
subq %r12, %rcx
cmpq %r15, %rcx
jb 0x1f0dbd
testq %r15, %r15
je 0x1f0d96
incq %rcx
subq %r15, %rcx
je 0x1f0dc2
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
cmpq %rdx, %rcx
jae 0x1f0dc2
movl %ecx, %edx
jmp 0x1f0d98
subq %r12, %r15
jb 0x1f0dc7
movq %r15, %rcx
shrq %rcx
cmpq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
jae 0x1f0dcc
incl %r15d
movl %r15d, %edx
jmp 0x1f0d98
xorl %edx, %edx
movl %edx, 0x10(%rax)
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
callq 0x1f0dfc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x78608
callq 0x7867a
callq 0x78641
callq 0x786ec
callq 0x786b3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_extractleafnode
static GtBlindtriesnodeptr blindtrie_extractleafnode(GtBlindtrie *blindtrie,
                                                     GtBlindtriesnodeptr head)
{
  gt_assert(!blindtrie_isleaf(blindtrie,head));
  do
  {
    head = blindtrie_firstchild_get(blindtrie,head);
  } while (!blindtrie_isleaf(blindtrie,head));
  return head;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1f04d3
testb %al, %al
jne 0x1f0e5b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1f0b7f
movl %eax, %ebp
movq %rbx, %rdi
movl %eax, %esi
callq 0x1f04d3
testb %al, %al
je 0x1f0e38
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x78795
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-copysort.c
// Function: comparesuperbucketsizes
static int comparesuperbucketsizes(const void *a,const void *b,void *data)
{
  const GtBucketspec2 *bucketspec2 = (const GtBucketspec2 *) data;
  GtUword size1 = superbucketsize(bucketspec2, *(const unsigned int *) a);
  GtUword size2 = superbucketsize(bucketspec2, *(const unsigned int *) b);
  if (size1 < size2)
  {
    return -1;
  }
  if (size1 > size2)
  {
    return 1;
  }
  return 0;
}

// Assembly:
movl (%rdi), %edi
movq 0x38(%rdx), %rcx
testq %rdi, %rdi
je 0x1f14ad
movq %rdi, %rax
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rax
decl %edi
shlq $0x4, %rdi
subq 0x8(%rcx,%rdi), %rax
jmp 0x1f14b1
movq 0x8(%rcx), %rax
movl (%rsi), %esi
movq 0x38(%rdx), %rcx
testq %rsi, %rsi
je 0x1f14d5
movq %rsi, %rdx
shlq $0x4, %rdx
movq 0x8(%rcx,%rdx), %rdx
decl %esi
shlq $0x4, %rsi
subq 0x8(%rcx,%rsi), %rdx
jmp 0x1f14d9
movq 0x8(%rcx), %rdx
xorl %ecx, %ecx
cmpq %rdx, %rax
seta %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-copysort.c
// Function: resetsorted
static void resetsorted(GtBucketspec2 *bucketspec2)
{
  unsigned int idx, idx2;

  for (idx = 0; idx<bucketspec2->numofchars; idx++)
  {
    bucketspec2->superbuckettab[idx].sorted = false;
    for (idx2 = 0; idx2<bucketspec2->numofchars; idx2++)
    {
      GtUword startidx = getstartidx(bucketspec2,idx,idx2),
             endidx = getendidx(bucketspec2,idx,idx2);
      bucketspec2->subbuckettab[idx][idx2].sorted =
        (startidx < endidx) ? false : true;
    }
  }
}

// Assembly:
cmpl $0x0, 0x14(%rdi)
je 0x1f1574
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
movq %r14, %rcx
shlq $0x4, %rcx
movb $0x0, 0x1(%rax,%rcx)
cmpl $0x0, 0x14(%rbx)
je 0x1f1560
movl $0x1, %r13d
xorl %r15d, %r15d
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x1f1ac1
movq %rax, %r12
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
callq 0x1f1a7c
cmpq %rax, %r12
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rax
setae (%rax,%r13)
incq %r15
movl 0x14(%rbx), %eax
addq $0x10, %r13
cmpq %rax, %r15
jb 0x1f1522
incq %r14
movl 0x14(%rbx), %eax
cmpq %rax, %r14
jb 0x1f1503
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-copysort.c
// Function: getendidx
static GtUword getendidx(const GtBucketspec2 *bucketspec2,
                        unsigned int first,
                        unsigned int second)
{
  gt_assert(first < bucketspec2->numofchars);
  gt_assert(second <= bucketspec2->numofchars);
  if (second < bucketspec2->numofchars)
  {
    return bucketspec2->subbuckettab[first][second].bucketend;
  }
  return bucketspec2->superbuckettab[first].bucketend;
}

// Assembly:
pushq %rax
movl 0x14(%rdi), %eax
cmpl %esi, %eax
jbe 0x1f1ab7
cmpl %edx, %eax
jb 0x1f1abc
movl %esi, %eax
jbe 0x1f1aa3
movq 0x40(%rdi), %rcx
movq (%rcx,%rax,8), %rax
movl %edx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addq $0x8, %rax
jmp 0x1f1ab2
movq 0x38(%rdi), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $0x8, %rax
movq (%rax), %rax
popq %rcx
retq
callq 0x78b5e
callq 0x78b95
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-copysort.c
// Function: getstartidx
static GtUword getstartidx(const GtBucketspec2 *bucketspec2,
                                 unsigned int first,
                                 unsigned int second)
{
  gt_assert(first < bucketspec2->numofchars);
  gt_assert(second <= bucketspec2->numofchars);
  if (second > 0)
  {
    return bucketspec2->subbuckettab[first][second-1].bucketend;
  }
  if (first > 0)
  {
    return bucketspec2->superbuckettab[first-1].bucketend;
  }
  return 0;
}

// Assembly:
pushq %rax
movl 0x14(%rdi), %eax
cmpl %esi, %eax
jbe 0x1f1afe
cmpl %edx, %eax
jb 0x1f1b03
testl %edx, %edx
je 0x1f1add
movl %esi, %eax
shlq $0x3, %rax
addq 0x40(%rdi), %rax
jmp 0x1f1aea
testl %esi, %esi
je 0x1f1afa
addq $0x38, %rdi
movq %rdi, %rax
movl %esi, %edx
movq (%rax), %rax
decl %edx
shlq $0x4, %rdx
movq 0x8(%rax,%rdx), %rax
popq %rcx
retq
xorl %eax, %eax
jmp 0x1f1af8
callq 0x78bcc
callq 0x78c03
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-copysort.c
// Function: gt_copysort_delete
void gt_copysort_delete(GtBucketspec2 *bucketspec2)
{
  gt_assert(bucketspec2 != NULL);
  gt_array2dim_delete(bucketspec2->subbuckettab);
  gt_free(bucketspec2->superbuckettab);
  gt_free(bucketspec2->order);
  gt_free(bucketspec2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1f1b79
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq (%rax), %rdi
leaq 0x1ce0af(%rip), %r14    # 0x3bfbd1
movq %r14, %rsi
movl $0x217, %edx            # imm = 0x217
callq 0x109670
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x217, %edx            # imm = 0x217
callq 0x109670
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x218, %edx            # imm = 0x218
callq 0x109670
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x219, %edx            # imm = 0x219
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x21a, %edx            # imm = 0x21A
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
callq 0x78c3a
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_differencecover_delete
void gt_differencecover_delete(GtDifferencecover *dcov)
{
  if (dcov != NULL)
  {
    gt_assert(dcov->bcktab == NULL);
    gt_assert(dcov->sortedsample == NULL);
    gt_assert(dcov->filltable == NULL);
    gt_assert(dcov->multimappower == NULL);
    gt_free(dcov->coverrank_evaluated);
    dcov->coverrank_evaluated = NULL;
    gt_free(dcov->coverrank_bits);
    dcov->coverrank_bits = NULL;
    gt_free(dcov->diff2pos);
    dcov->diff2pos = NULL;
    gt_free(dcov->inversesuftab);
    dcov->inversesuftab = NULL;
    gt_rmq_delete(dcov->rmq);
    dcov->rmq = NULL;
    gt_free(dcov);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1f1f16
movq %rdi, %rbx
cmpq $0x0, 0x58(%rdi)
jne 0x1f1f1c
cmpq $0x0, 0x148(%rbx)
jne 0x1f1f21
cmpq $0x0, 0x90(%rbx)
jne 0x1f1f26
cmpq $0x0, 0x88(%rbx)
jne 0x1f1f2b
movq 0x20(%rbx), %rdi
leaq 0x1ce0bb(%rip), %r14    # 0x3bff50
movq %r14, %rsi
movl $0x213, %edx            # imm = 0x213
callq 0x109670
xorl %r15d, %r15d
movq %r15, 0x20(%rbx)
movq 0x28(%rbx), %rdi
movq %r14, %rsi
movl $0x215, %edx            # imm = 0x215
callq 0x109670
movq %r15, 0x28(%rbx)
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x217, %edx            # imm = 0x217
callq 0x109670
movq %r15, 0x38(%rbx)
movq 0x98(%rbx), %rdi
movq %r14, %rsi
movl $0x219, %edx            # imm = 0x219
callq 0x109670
movq %r15, 0x98(%rbx)
movq 0x150(%rbx), %rdi
callq 0x177e47
movq %r15, 0x150(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x21d, %edx            # imm = 0x21D
popq %rbx
popq %r14
popq %r15
jmp 0x109670
popq %rbx
popq %r14
popq %r15
retq
callq 0x78d1e
callq 0x78d57
callq 0x78d90
callq 0x78dc9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_inl_dc_queue_new
static GtInlDCQueue *gt_inl_dc_queue_new(GtUword queuesize)
{
  GtInlDCQueue *q;

  q = gt_malloc(sizeof (*q));
  gt_assert(queuesize > 0);
  q->queuespace = gt_malloc(sizeof (*q->queuespace) * queuesize);
  q->noofelements = 0;
  q->queuesize = queuesize;
  q->dequeueindex = q->enqueueindex = queuesize - 1;
  return q;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1cb827(%rip), %r14    # 0x3bff50
movl $0x28, %edi
movq %r14, %rsi
movl $0x83, %edx
callq 0x1092b2
movq %rax, %r15
movq %rbx, %rdi
shlq $0x4, %rdi
movq %r14, %rsi
movl $0x85, %edx
callq 0x1092b2
movq %rax, (%r15)
movq $0x0, 0x20(%r15)
movq %rbx, 0x18(%r15)
decq %rbx
movq %rbx, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_addunsortedrange
static void dc_addunsortedrange(void *voiddcov,
                                GT_UNUSED GtSuffixsortspace *sssp,
                                GtUword blisbl,
                                GtUword width,
                                GT_UNUSED GtUword depth)
{
  GtDifferencecover *dcov = (GtDifferencecover *) voiddcov;
  GtDcPairsuffixptr *ptr;

  gt_assert(depth >= (GtUword) dcov->vparam);
  dc_updatewidth (dcov,width,dcov->vparam);
  GT_GETNEXTFREEINARRAY(ptr,&dcov->firstgeneration,GtDcPairsuffixptr,1024);
  ptr->blisbl = blisbl;
  ptr->width = width;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl (%rdi), %edx
cmpq %r8, %rdx
ja 0x1f4c29
movq %rcx, %rbx
movq %rdi, %r15
movq %rcx, %rsi
callq 0x1f4fb7
movq 0x118(%r15), %rsi
cmpq %rsi, 0x120(%r15)
jb 0x1f4bf8
addq $0x400, %rsi            # imm = 0x400
movq %rsi, 0x118(%r15)
movq 0x110(%r15), %rdi
shlq $0x4, %rsi
leaq 0x1cb369(%rip), %rdx    # 0x3bff50
movl $0x45e, %ecx            # imm = 0x45E
callq 0x1094e6
movq %rax, 0x110(%r15)
movq 0x110(%r15), %rax
testq %rax, %rax
je 0x1f4c2e
movq 0x120(%r15), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x120(%r15)
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x79ead
callq 0x79e74
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_filldiff2pos
static void dc_filldiff2pos(GtDifferencecover *dcov)
{
  Diffvalue *iptr, *jptr;

  gt_assert(dcov->diff2pos == NULL);
  dcov->diff2pos = gt_malloc(sizeof (*dcov->diff2pos) * dcov->vparam);
  dcov->requiredspace += sizeof (*dcov->diff2pos) * dcov->vparam;
  for (iptr=dcov->diffvalues + dcov->size - 1; iptr>=dcov->diffvalues; iptr--)
  {
    for (jptr=dcov->diffvalues; jptr<dcov->diffvalues + dcov->size; jptr++)
    {
      dcov->diff2pos[GT_MODV(*jptr - *iptr)] = *iptr;
    }
  }
}

// Assembly:
pushq %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x1f4f53
movq %rdi, %rbx
movl (%rdi), %edi
addq %rdi, %rdi
leaq 0x1cb05e(%rip), %rsi    # 0x3bff50
movl $0x169, %edx            # imm = 0x169
callq 0x1092b2
movq %rax, 0x38(%rbx)
movl (%rbx), %edx
movl 0x8(%rbx), %ecx
addq %rdx, %rdx
addq %rdx, 0x40(%rbx)
movq 0x30(%rbx), %rdx
leaq (%rdx,%rcx,2), %rsi
addq $-0x2, %rsi
cmpq %rdx, %rsi
jb 0x1f4f51
leaq (%rdx,%rcx,2), %rdi
testl %ecx, %ecx
je 0x1f4f48
movl 0xc(%rbx), %r8d
movq %rdx, %r9
movzwl (%rsi), %r10d
movzwl (%r9), %r11d
subl %r10d, %r11d
andl %r8d, %r11d
movw %r10w, (%rax,%r11,2)
addq $0x2, %r9
cmpq %rdi, %r9
jb 0x1f4f2c
addq $-0x2, %rsi
cmpq %rdx, %rsi
jae 0x1f4f21
popq %rbx
retq
callq 0x79f91
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_updatewidth
static void dc_updatewidth (GtDifferencecover *dcov,GtUword width,
                            unsigned int depth)
{
  if (width > 1UL)
  {
    gt_assert(dcov != NULL);
    dcov->firstgenerationtotalwidth += width;
    dcov->firstgenerationcount++;
    if (dcov->allocateditvinfo < width)
    {
      dcov->allocateditvinfo = width;
    }
    if (dcov->currentdepth == 0)
    {
      dcov->currentdepth = (GtUword) depth;
    } else
    {
      gt_assert(dcov->currentdepth == (GtUword) depth);
    }
  }
}

// Assembly:
pushq %rax
cmpq $0x2, %rsi
jb 0x1f5014
testq %rdi, %rdi
je 0x1f5016
movdqu 0x130(%rdi), %xmm0
movq %rsi, %xmm1
shufpd $0x2, 0x16ca97(%rip), %xmm1 # xmm1 = xmm1[0],mem[1]
paddq %xmm0, %xmm1
movdqu %xmm1, 0x130(%rdi)
cmpq %rsi, 0xa0(%rdi)
jae 0x1f4ff5
movq %rsi, 0xa0(%rdi)
movq 0xb8(%rdi), %rax
movl %edx, %ecx
testq %rax, %rax
je 0x1f500d
cmpq %rcx, %rax
je 0x1f5014
callq 0x7a03c
movq %rcx, 0xb8(%rdi)
popq %rax
retq
callq 0x7a075
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_qsortcmparr
static int QSORTNAME(qsortcmparr) (GtUword a,
                                   GtUword b,
                                   const GtDifferencecover *dcov,
                                   GtLcptrace *lcptrace,
                                   GtUword subbucketleft,
                                   const QSORTNAME(Datatype) sssp)
{
  GtUword suffixpos1, suffixpos2;

  gt_assert(sssp != NULL);
  suffixpos1 = dc_ARRAY_GET(sssp,a);
  suffixpos2 = dc_ARRAY_GET(sssp,b);
  return gt_differencecover_compare (dcov, lcptrace, suffixpos1, suffixpos2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rdx
movq %r9, %rdi
movq %r8, %rsi
callq 0x206063
movq %rax, %r12
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x206063
movq %rax, %r15
movq 0x48(%r14), %rax
cmpq %r12, %rax
jbe 0x1f580a
cmpq %r15, %rax
jbe 0x1f580a
testq %r14, %r14
je 0x1f580f
movq 0x38(%r14), %rax
movl %r15d, %ecx
subl %r12d, %ecx
movl 0xc(%r14), %edx
andl %edx, %ecx
movzwl (%rax,%rcx,2), %esi
subl %r12d, %esi
andl %edx, %esi
movl %esi, (%rbx)
addq %r12, %rsi
movq 0x98(%r14), %r12
movq %r14, %rdi
callq 0x1f4f82
movl (%r12,%rax,4), %eax
movq %rax, 0x8(%rbx)
movl (%rbx), %esi
addq %r15, %rsi
movq 0x98(%r14), %r15
movq %r14, %rdi
callq 0x1f4f82
movl (%r15,%rax,4), %ecx
movq %rcx, 0x10(%rbx)
movq 0x8(%rbx), %rdx
cmpq %rcx, %rdx
je 0x1f5814
xorl %eax, %eax
cmpq %rcx, %rdx
sbbl %eax, %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7a319
callq 0x7a38b
callq 0x7a352
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_differencecover_eval_lcp
static GtUword gt_differencecover_eval_lcp(const GtLcptrace *lcptrace,
                                           const GtDifferencecover *dcov)
{
  if (lcptrace->idx1 < dcov->effectivesamplesize &&
      lcptrace->idx2 < dcov->effectivesamplesize)
  {
    gt_assert(dcov->rmq != NULL);
    return (GtUword)
            gt_rmq_find_min_value(dcov->rmq,
                                  GT_MIN(lcptrace->idx1,lcptrace->idx2)+1,
                                  GT_MAX(lcptrace->idx1,lcptrace->idx2))
             + lcptrace->offset;
  }
  return (GtUword) lcptrace->offset;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x78(%rsi), %rcx
cmpq %rcx, %rax
jae 0x1f585e
movq 0x10(%rbx), %rdx
cmpq %rcx, %rdx
jae 0x1f585e
movq 0x150(%rsi), %rdi
testq %rdi, %rdi
je 0x1f5862
cmpq %rdx, %rax
movq %rdx, %rsi
cmovbq %rax, %rsi
cmovaq %rax, %rdx
incq %rsi
callq 0x1777cf
movl %eax, %ecx
movl (%rbx), %eax
addq %rcx, %rax
jmp 0x1f5860
movl (%rbx), %eax
popq %rbx
retq
callq 0x7a3c4
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_new
Enumcodeatposition *gt_Enumcodeatposition_new(const GtEncseq *encseq,
                                              GtReadmode readmode,
                                              unsigned int prefixlength,
                                              unsigned int numofchars)
{
  Enumcodeatposition *ecp;

  ecp = gt_malloc(sizeof *ecp);
  ecp->encseq = encseq;
  ecp->readmode = readmode;
  ecp->multimappower = gt_initmultimappower(numofchars,prefixlength);
  ecp->filltable = gt_initfilltable(numofchars,prefixlength);
  ecp->prefixlength = prefixlength;
  ecp->moveforward = GT_ISDIRREVERSE(readmode) ? true : false;
  ecp->totallength = gt_encseq_total_length(encseq);
  if (ecp->moveforward)
  {
    ecp->previousrange.start = ecp->previousrange.end = 0;
  } else
  {
    ecp->previousrange.start = ecp->previousrange.end = ecp->totallength;
  }
  ecp->exhausted = false;
  if (gt_encseq_has_specialranges(encseq))
  {
    ecp->sri = gt_specialrangeiterator_new(encseq,ecp->moveforward);
  } else
  {
    ecp->sri = NULL;
  }
  return ecp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
leaq 0x1cb579(%rip), %rsi    # 0x3c0dfb
movl $0x50, %edi
movl $0x2e, %edx
callq 0x1092b2
movq %rax, %rbx
movq %r14, 0x30(%rax)
movl %r12d, 0x38(%rax)
movl %ebp, %edi
movl %r15d, %esi
callq 0x1bee83
movq %rax, 0x40(%rbx)
movl %ebp, %edi
movl %r15d, %esi
callq 0x1bee14
movq %rax, 0x48(%rbx)
movl %r15d, 0x3c(%rbx)
andl $-0x3, %r12d
cmpl $0x1, %r12d
sete 0x18(%rbx)
movq %r14, %rdi
callq 0xec1d8
movq %rax, 0x20(%rbx)
xorl %r15d, %r15d
cmpb $0x0, 0x18(%rbx)
cmovneq %r15, %rax
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
movb $0x0, 0x28(%rbx)
movq %r14, %rdi
callq 0xef27f
testb %al, %al
je 0x1f5905
movzbl 0x18(%rbx), %esi
movq %r14, %rdi
callq 0xef3d9
movq %rax, %r15
movq %r15, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_next
bool gt_Enumcodeatposition_next(Specialcontext *specialcontext,
                                Enumcodeatposition *ecp)
{
  GtRange currentrange;
  bool done;

  if (ecp->exhausted)
  {
    return false;
  }
  while (ecp->sri != NULL)
  {
    if (!gt_specialrangeiterator_next(ecp->sri,&currentrange))
    {
      gt_specialrangeiterator_delete(ecp->sri);
      ecp->sri = NULL;
      break;
    }
    if (ecp->moveforward)
    {
      if (newcodelistelem(specialcontext,
                          ecp->previousrange.end,
                          currentrange.start,
                          ecp))
      {
        ecp->previousrange = currentrange;
        return true;
      }
    } else
    {
      if (newcodelistelem(specialcontext,
                          currentrange.end,
                          ecp->previousrange.start,
                          ecp))
      {
        ecp->previousrange = currentrange;
        return true;
      }
    }
    ecp->previousrange = currentrange;
  }
  ecp->exhausted = true;
  if (ecp->moveforward)
  {
    done = newcodelistelem(specialcontext,
                           ecp->previousrange.end,
                           ecp->totallength,
                           ecp);
  } else
  {
    done = newcodelistelem(specialcontext,
                           0,
                           ecp->previousrange.start,
                           ecp);
  }
  return done;
}

// Assembly:
cmpb $0x0, 0x28(%rsi)
je 0x1f591e
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rdi
testq %rdi, %rdi
je 0x1f598f
movq %rsp, %r15
movq %r15, %rsi
callq 0xef451
testb %al, %al
je 0x1f597e
cmpb $0x1, 0x18(%rbx)
jne 0x1f5955
movq 0x8(%rbx), %rsi
movq (%rsp), %rdx
jmp 0x1f595d
movq 0x8(%rsp), %rsi
movq (%rbx), %rdx
movq %r14, %rdi
movq %rbx, %rcx
callq 0x1f59cb
testb %al, %al
jne 0x1f59b8
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
jne 0x1f5939
jmp 0x1f598f
movq 0x10(%rbx), %rdi
callq 0xefa48
movq $0x0, 0x10(%rbx)
movb $0x1, 0x28(%rbx)
cmpb $0x1, 0x18(%rbx)
jne 0x1f59a6
movq 0x8(%rbx), %rsi
movq 0x20(%rbx), %rdx
movq %r14, %rdi
jmp 0x1f59ae
movq (%rbx), %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rcx
callq 0x1f59cb
jmp 0x1f59c1
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_delete
void gt_Enumcodeatposition_delete(Enumcodeatposition *ecp)
{
  if (ecp != NULL)
  {
    gt_free(ecp->filltable);
    gt_multimappower_delete(ecp->multimappower);
    gt_free(ecp);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1f5a4b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x1cb3dd(%rip), %r14    # 0x3c0dfb
movq %r14, %rsi
movl $0xa2, %edx
callq 0x109670
movq 0x40(%rbx), %rdi
callq 0x1bef6c
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa4, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_filledqgramcode
GtCodetype gt_Enumcodeatposition_filledqgramcode(const Enumcodeatposition *ecp,
                                                 unsigned int prefixindex,
                                                 GtUword pos)
{
  GtCodetype code;
  unsigned int idx;
  GtUchar cc;

  gt_assert(prefixindex > 0 && prefixindex < ecp->prefixlength);
  code = ecp->filltable[prefixindex];
  for (idx=0; idx<prefixindex; idx++)
  {
    gt_assert((GtUword) (pos + idx) < ecp->totallength);
    cc = gt_encseq_get_encoded_char_nospecial(ecp->encseq,
                                              pos + idx,
                                              ecp->readmode);
    gt_assert(GT_ISNOTSPECIAL(cc));
    code += ecp->multimappower[idx][cc];
  }
  return code;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testl %esi, %esi
je 0x1f5abb
movq %rdi, %r14
cmpl %esi, 0x3c(%rdi)
jbe 0x1f5abb
movq %rdx, %rbx
movq 0x48(%r14), %rax
movl %esi, %r12d
movq (%rax,%r12,8), %r15
xorl %r13d, %r13d
leaq (%rbx,%r13), %rsi
cmpq 0x20(%r14), %rsi
jae 0x1f5ab6
movq 0x30(%r14), %rdi
movl 0x38(%r14), %edx
callq 0xec603
cmpb $-0x2, %al
jae 0x1f5ab1
movq 0x40(%r14), %rcx
movq (%rcx,%r13,8), %rcx
movzbl %al, %eax
addq (%rcx,%rax,8), %r15
incq %r13
cmpq %r13, %r12
jne 0x1f5a72
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x7a46d
callq 0x7a434
callq 0x7a4a6