LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-polish.c
// Function: polishing_info_show
void polishing_info_show(const GtFtPolishing_info *pol_info)
{
  GtUword idx;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0x1f7d41(%rip), %rdi    # 0x3b0234
xorl %eax, %eax
callq 0x17070
movq (%rbx), %rsi
leaq 0x1f7d43(%rip), %rdi    # 0x3b0247
xorl %eax, %eax
callq 0x17070
movq 0x28(%rbx), %rsi
leaq 0x1f7d42(%rip), %rdi    # 0x3b0258
xorl %eax, %eax
callq 0x17070
movq 0x20(%rbx), %rsi
leaq 0x1f7d45(%rip), %rdi    # 0x3b026d
xorl %eax, %eax
callq 0x17070
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x1b85a4
leaq 0x1f7d44(%rip), %rdi    # 0x3b0287
leaq 0x3113d6(%rip), %rsi    # 0x4c9920
xorl %eax, %eax
callq 0x17070
cmpq $0x0, (%rbx)
je 0x1b8598
leaq 0x1f7d36(%rip), %r14    # 0x3b0294
leaq 0x3113bb(%rip), %r15    # 0x4c9920
xorl %r12d, %r12d
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x1b85a4
movq 0x30(%rbx), %rax
movswl (%rax,%r12,4), %edx
movswl 0x2(%rax,%r12,4), %ecx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x17070
incq %r12
cmpq (%rbx), %r12
jb 0x1b8568
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-polish.c
// Function: polish_intbits2string
static char *polish_intbits2string(GtUword bits,GtUword bs)
{
  char *csptr;
  GtUword mask;
  static char cs[64+1];

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

// Assembly:
pushq %rax
decq %rdi
cmpq $0x40, %rdi
jae 0x1b85e4
movl $0x1, %eax
movl %edi, %ecx
shlq %cl, %rax
leaq 0x311361(%rip), %rcx    # 0x4c9920
movq %rax, %rdx
testq %rsi, %rax
sete %dil
xorb $0x31, %dil
movb %dil, (%rcx)
shrq %rdx
incq %rcx
cmpq $0x1, %rax
movq %rdx, %rax
ja 0x1b85c2
movb $0x0, (%rcx)
popq %rax
retq
callq 0x662ff
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-polish.c
// Function: history_is_polished_brute_force
bool history_is_polished_brute_force(const GtFtPolishing_info *pol_info,
                                     uint64_t matchhistory,
                                     bool withoutput)
{
  GtUword idx;
  uint64_t mask;
  GtWord sum_score = 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
shlq %rax
testq %rax, %rax
sete %bpl
je 0x1b869c
movl %edx, %r14d
movq %rsi, %r15
movl $0x1, %ebx
xorl %r13d, %r13d
xorl %r12d, %r12d
movq %rdi, (%rsp)
testq %r15, %rbx
je 0x1b8660
addq 0x28(%rdi), %r13
jmp 0x1b8664
subq 0x20(%rdi), %r13
testb %r14b, %r14b
je 0x1b8681
leaq 0x1f7c34(%rip), %rdi    # 0x3b02a4
movq %r12, %rsi
movq %r13, %rdx
xorl %eax, %eax
callq 0x17070
movq (%rsp), %rdi
testq %r13, %r13
js 0x1b869c
incq %r12
addq %rbx, %rbx
movq 0x8(%rdi), %rax
addq %rax, %rax
cmpq %rax, %r12
setae %bpl
jb 0x1b8655
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %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/ft-trimstat.c
// Function: gt_ft_trimstat_new
GtFtTrimstat *gt_ft_trimstat_new(void)
{
  GtFtTrimstat *trimstat = gt_malloc(sizeof *trimstat);

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

// Assembly:
pushq %rbx
leaq 0x1f7d1c(%rip), %rsi    # 0x3b03d8
movl $0x58, %edi
movl $0x11, %edx
callq 0x1092b2
testq %rax, %rax
je 0x1b873a
movq %rax, %rbx
leaq 0x1f7cfe(%rip), %rdx    # 0x3b03d8
movl $0x65, %edi
movl $0x8, %esi
movl $0x14, %ecx
callq 0x1093ef
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x1b873f
leaq 0x1f7cda(%rip), %rdx    # 0x3b03d8
movl $0x65, %edi
movl $0x8, %esi
movl $0x17, %ecx
callq 0x1093ef
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x1b8744
movq $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x663a4
callq 0x6636d
callq 0x66336
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/ft-trimstat.c
// Function: gt_ft_trimstat_delete
void gt_ft_trimstat_delete(GtFtTrimstat *trimstat)
{
  if (trimstat != NULL)
  {
    gt_free(trimstat->trim_dist);
    GT_FREEARRAY(&trimstat->distance_dist,GtUword);
    GT_FREEARRAY(&trimstat->maxvalid_dist,GtUword);
    gt_free(trimstat->matchlength_dist);
    gt_free(trimstat);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1b8a44
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1f7a27(%rip), %rsi    # 0x3b03d8
movl $0x81, %edx
callq 0x109670
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1b89e8
leaq 0x18(%rbx), %r14
leaq 0x1f7a09(%rip), %rsi    # 0x3b03d8
movl $0x82, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1b8a15
leaq 0x30(%rbx), %r14
leaq 0x1f79dc(%rip), %rsi    # 0x3b03d8
movl $0x83, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x10(%rbx), %rdi
leaq 0x1f79b8(%rip), %r14    # 0x3b03d8
movq %r14, %rsi
movl $0x84, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x85, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_new
GtGfaWriter* gt_gfa_writer_new(GtFile *file,
                               const GtEncseq *encseq,
                               GtGfaVersion version)
{
  GtGfaWriter *gw;
  gw = gt_malloc(sizeof (*gw));
  gw->file = gt_file_ref(file);
  gw->encseq = gt_encseq_ref((GtEncseq*)encseq);
  gw->version = version;
  return gw;
}

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

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1b8dce
movq %rdx, %rax
movq %rsi, %r10
movq %rdi, %rdx
movq (%rdi), %rdi
movl 0x10(%rdx), %edx
testl %edx, %edx
je 0x1b8d9d
cmpl $0x1, %edx
jne 0x1b8dd3
leaq 0x1a3aa1(%rip), %rdx    # 0x35c83c
jmp 0x1b8da4
leaq 0x1a3a86(%rip), %rdx    # 0x35c82a
movzbl %cl, %r9d
orl $0x30, %r9d
movzbl %r8b, %ecx
orl $0x30, %ecx
movl %ecx, (%rsp)
leaq 0x1f783b(%rip), %rsi    # 0x3b05f8
movq %r10, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x103d21
xorl %eax, %eax
popq %rcx
retq
callq 0x664b7
callq 0x66480
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_spmproc_show_gfa
void gt_spmproc_show_gfa(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *gfa_writer)
{
  GtGfaWriter *gw = gfa_writer;
  const GtUword sl1 = gt_encseq_seqlength(gw->encseq, suffix_readnum),
                sl2 = gt_encseq_seqlength(gw->encseq, prefix_readnum);
  gt_gfa_writer_show_edge(gw->version, gw->file,
      suffix_readnum, suffixseq_direct,
      prefix_readnum, prefixseq_direct,
      suffixseq_direct ? sl1 - length : 0,
      suffixseq_direct ? sl1 : length,
      suffixseq_direct,
      prefixseq_direct ? 0 : sl2 - length,
      prefixseq_direct ? length : sl2,
      !prefixseq_direct,
      length);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rsi
movq 0x8(%r9), %rdi
movq %rsi, (%rsp)
callq 0xeffd3
movq %rax, %rbx
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xeffd3
movq %rax, %r10
movl 0x10(%r14), %eax
movq (%r14), %rdi
cmpl $0x1, %eax
je 0x1b9017
movq (%rsp), %rdx
testl %eax, %eax
jne 0x1b90a3
xorb $0x1, %r13b
movzbl %r13b, %eax
leal 0x2b(,%rax,2), %ecx
xorb $0x1, %bpl
movzbl %bpl, %eax
leal 0x2b(,%rax,2), %r9d
subq $0x8, %rsp
leaq 0x1f76bc(%rip), %rsi    # 0x3b06be
movq %r15, %r8
xorl %eax, %eax
pushq %r12
callq 0x103d21
addq $0x18, %rsp
jmp 0x1b9098
movq %r10, %r14
subq %r12, %r14
movq %rbx, %r11
subq %r12, %r11
movl %r13d, %eax
xorb $0x1, %al
movl %ebp, %edx
xorb $0x1, %dl
xorl %ecx, %ecx
testb %r13b, %r13b
cmoveq %r12, %rbx
cmoveq %rcx, %r11
movq %r15, %r8
leaq 0x1bd38f(%rip), %r15    # 0x3763d3
leaq 0x21a845(%rip), %rsi    # 0x3d3890
movq %rsi, %r13
cmovneq %r15, %r13
testb %bpl, %bpl
cmovneq %r12, %r10
cmovneq %rcx, %r14
movzbl %al, %eax
leal 0x2b(%rax,%rax), %ecx
movzbl %dl, %eax
leal 0x2b(%rax,%rax), %r9d
cmovneq %rsi, %r15
subq $0x8, %rsp
leaq 0x1f7659(%rip), %rsi    # 0x3b06d4
movq 0x8(%rsp), %rdx
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r10
pushq %r14
pushq %r13
pushq %rbx
pushq %r11
callq 0x103d21
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6655c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/giextract.c
// Function: desc2key
static const char *desc2key(GtUword *keylen,const char *desc,
                            GtError *err)
{
  GtUword i, firstpipe = 0, secondpipe = 0;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1b9661
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1b96e3
xorl %eax, %eax
xorl %ecx, %ecx
movzbl (%rbx,%rax), %edx
cmpl $0x7c, %edx
je 0x1b9674
testl %edx, %edx
jne 0x1b9681
jmp 0x1b9686
testq %rcx, %rcx
jne 0x1b968a
movq %rax, %rcx
testq %rax, %rax
je 0x1b96de
incq %rax
jmp 0x1b9665
xorl %eax, %eax
jmp 0x1b968f
testq %rax, %rax
je 0x1b96ed
testq %rcx, %rcx
setne %dl
testq %rax, %rax
setne %sil
testb %sil, %dl
jne 0x1b96ba
leaq 0x1f7296(%rip), %rsi    # 0x3b093e
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1019cf
jmp 0x1b96cf
cmpq %rax, %rcx
jae 0x1b96e8
leaq (%rbx,%rcx), %r12
incq %r12
notq %rcx
addq %rcx, %rax
movq %rax, (%r14)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x6675d
callq 0x666eb
callq 0x66796
callq 0x66724
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/giextract.c
// Function: giextract_encodedseq2fasta
static int giextract_encodedseq2fasta(FILE *fpout,
                                      const GtEncseq *encseq,
                                      GtUword seqnum,
                                      const Fastakeyquery *fastakeyquery,
                                      GtUword linewidth,
                                      GT_UNUSED GtError *err)
{
  const char *desc;
  GtUword desclen;
  bool haserr = false;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rsi
movq %r14, %rdi
callq 0xf079f
movq %rax, %rbp
movl $0x3e, %edi
movq %r15, %rsi
callq 0x1255d6
testq %r12, %r12
je 0x1b975b
movq 0x8(%r12), %rdx
cmpq $0x1, %rdx
jne 0x1b9744
cmpq $0x0, 0x10(%r12)
je 0x1b975b
movq (%r12), %rsi
movq 0x10(%r12), %rcx
leaq 0x1f7225(%rip), %rdi    # 0x3b0979
xorl %eax, %eax
callq 0x17070
movq (%rsp), %rdx
movl $0x1, %esi
movq %rbp, %rdi
movq %r15, %rcx
callq 0x125658
movl $0xa, %edi
movq %r15, %rsi
callq 0x1255d6
movq %r14, %rdi
movq %r13, %rsi
callq 0xefce0
movq %rax, %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0xeffd3
testq %r12, %r12
je 0x1b97bd
movq 0x8(%r12), %rcx
cmpq $0x1, %rcx
jne 0x1b97ad
cmpq $0x0, 0x10(%r12)
je 0x1b97bd
movq 0x10(%r12), %rax
subq %rcx, %rax
decq %rcx
incq %rax
jmp 0x1b97bf
xorl %ecx, %ecx
addq %rbp, %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %r8
movq %rbx, %r9
callq 0x1a1056
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/giextract.c
// Function: fastakeyqueries_delete
static void fastakeyqueries_delete(Fastakeyquery *fastakeyqueries,
                                   GtUword numofqueries)
{
  if (fastakeyqueries != NULL)
  {
    GtUword idx;

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

// Assembly:
testq %rdi, %rdi
je 0x1ba3ff
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1ba3e0
leaq 0x1f633b(%rip), %r15    # 0x3b06fe
movq %rbx, %r12
movq (%r12), %rdi
movq %r15, %rsi
movl $0x9f, %edx
callq 0x109670
addq $0x20, %r12
decq %r14
jne 0x1ba3c6
leaq 0x1f6317(%rip), %rsi    # 0x3b06fe
movq %rbx, %rdi
movl $0xa1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/greedyedist.c
// Function: gt_frontresource_new
GtFrontResource *gt_frontresource_new(GtUword maxdist)
{
  GtFrontResource *ftres = gt_malloc(sizeof *ftres);

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

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

// Assembly:
testq %rdi, %rdi
je 0x1bae6c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1a9e1c
movq (%rbx), %rdi
leaq 0x1f5eb5(%rip), %rsi    # 0x3b0cf4
movl $0x37, %edx
callq 0x109670
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1bae57
callq 0x1a87ef
leaq 0x1f5e96(%rip), %rsi    # 0x3b0cf4
movq %rbx, %rdi
movl $0x3c, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_freeLimdfsresources
void gt_freeLimdfsresources(Limdfsresources **ptrlimdfsresources,
                         const AbstractDfstransformer *adfst)
{
  Limdfsresources *limdfsresources = *ptrlimdfsresources;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq *0x20(%rsi)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1bb249
leaq 0x8(%r14), %r12
leaq 0x1f5ac6(%rip), %rsi    # 0x3b0cf4
movl $0x17f, %edx            # imm = 0x17F
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
cmpq $0x0, 0x38(%r15)
je 0x1bb295
cmpq $0x0, 0x28(%r14)
je 0x1bb278
movl $0x28, %r12d
xorl %r13d, %r13d
movq 0x20(%r14), %rdi
addq %r12, %rdi
callq *0x38(%r15)
incq %r13
addq $0x60, %r12
cmpq 0x28(%r14), %r13
jb 0x1bb260
cmpb $0x0, 0xc8(%r14)
jne 0x1bb295
leaq 0x98(%r14), %rdi
callq *0x38(%r15)
leaq 0x60(%r14), %rdi
callq *0x38(%r15)
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x1bb2c2
leaq 0x20(%r14), %r15
leaq 0x1f5a4b(%rip), %rsi    # 0x3b0cf4
movl $0x190, %edx            # imm = 0x190
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0xf0(%r14), %rdi
leaq 0x1f5a24(%rip), %r15    # 0x3b0cf4
movq %r15, %rsi
movl $0x191, %edx            # imm = 0x191
callq 0x109670
movq 0x118(%r14), %rdi
movq %r15, %rsi
movl $0x192, %edx            # imm = 0x192
callq 0x109670
movq 0x100(%r14), %rdi
testq %rdi, %rdi
je 0x1bb324
addq $0x100, %r14            # imm = 0x100
leaq 0x1f59e9(%rip), %rsi    # 0x3b0cf4
movl $0x193, %edx            # imm = 0x193
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq (%rbx), %rdi
leaq 0x1f59c6(%rip), %rsi    # 0x3b0cf4
movl $0x194, %edx            # imm = 0x194
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_fromitv2sortedmatchpositions
GtArrayGtUword *gt_fromitv2sortedmatchpositions(
                                             Limdfsresources *limdfsresources,
                                             GtUword leftbound,
                                             GtUword rightbound,
                                             GtUword offset)
{
  Indexbounds itv;
  GtIdxMatch match;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rdi, %rdi
je 0x1bb43e
movq %rdi, %r14
movq 0xd8(%rdi), %rdi
testq %rdi, %rdi
je 0x1bb43e
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x100(%r14), %r12
xorl %edx, %edx
movq %rdx, 0x110(%r14)
leaq 0x8(%rsp), %rax
movq %rsi, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rcx, (%rax)
leaq 0x30(%rsp), %r9
movb $0x1, (%r9)
movq %rcx, 0x18(%r9)
movq 0x118(%r14), %rsi
movq %rsi, 0x20(%r9)
movq %rdx, 0x28(%r9)
movq %rcx, 0x30(%r9)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r9)
leaq 0x86(%rip), %rcx        # 0x1bb443
cmpb $0x0, 0x18(%rdi)
leaq 0xd0(%rip), %r10        # 0x1bb498
cmovneq %rcx, %r10
movq 0x8(%rdi), %r8
leaq 0x148(%rip), %rsi       # 0x1bb51f
movq %r12, %rdx
movq %rax, %rcx
callq *%r10
movq 0x100(%r14), %rdi
movq 0x110(%r14), %rsi
leaq 0x18e(%rip), %rcx       # 0x1bb583
movl $0x8, %edx
callq 0x17f60
movq 0xd8(%r14), %rax
cmpb $0x1, 0x18(%rax)
jne 0x1bb425
movq 0x128(%r14), %rax
subq %r15, %rbx
addq %rbx, %rax
incq %rax
movq %rax, 0x128(%r14)
jmp 0x1bb42f
subq %r15, %rbx
addq %rbx, 0x128(%r14)
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x66b0d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gen_esa_overinterval
static void gen_esa_overinterval(const Genericindex *genericindex,
                                 ProcessIdxMatch processmatch,
                                 void *processmatchinfo,
                                 const Indexbounds *itv,
                                 GT_UNUSED GtUword totallength,
                                 GtIdxMatch *match)
{
  GtUword idx;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rcx), %rbp
cmpq 0x10(%rcx), %rbp
ja 0x1bb489
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%r13), %rax
movq 0x58(%rax), %rax
movq (%rax,%rbp,8), %rax
movq %rax, 0x10(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq *%r12
incq %rbp
cmpq 0x10(%r14), %rbp
jbe 0x1bb467
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gen_pck_overinterval
static void gen_pck_overinterval(const Genericindex *genericindex,
                                 ProcessIdxMatch processmatch,
                                 void *processmatchinfo,
                                 const Indexbounds *itv,
                                 GtUword totallength,
                                 GtIdxMatch *match)
{
  Bwtseqpositioniterator *bspi;
  GtUword dbstartpos;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r13
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
cmpq %rdx, %rsi
jae 0x1bb51a
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq 0x10(%rdi), %rdi
callq 0x1a80c9
movq %rax, %rbp
movq %rsp, %rdi
movq %rax, %rsi
callq 0x1a8115
testb %al, %al
je 0x1bb4fe
movq (%r15), %rcx
addq (%rsp), %rcx
movq %r14, %rax
subq %rcx, %rax
jb 0x1bb515
movq %rax, 0x10(%rbx)
movq %r12, %rdi
movq %rbx, %rsi
callq *%r13
movq %rsp, %rdi
movq %rbp, %rsi
jmp 0x1bb4d1
movq %rbp, %rdi
callq 0x1a81ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x66b7f
callq 0x66b46
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbasedapproxpatternmatching
bool gt_indexbasedapproxpatternmatching(Limdfsresources *limdfsresources,
                                     const GtUchar *pattern,
                                     GtUword patternlength,
                                     GtUword maxdistance,
                                     GtUword maxintervalwidth,
                                     bool skpp,
                                     const AbstractDfstransformer *adfst)
{
  adfst->initdfsconstinfo(limdfsresources->dfsconstinfo,
                          (unsigned int) limdfsresources->alphasize,
                          pattern,
                          patternlength,
                          maxdistance,
                          maxintervalwidth,
                          skpp);
  runlimdfs(limdfsresources,adfst);
  return (limdfsresources->numberofmatches > 0) ? true : false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rax
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x20(%rsp), %r14
movq (%rdi), %rdi
movzbl 0xc9(%rbx), %esi
movl %r9d, (%rsp)
movq %rax, %r9
xorl %eax, %eax
callq *0x10(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1bb5de
cmpq $0x0, 0x128(%rbx)
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbasedmstats
void gt_indexbasedmstats(Limdfsresources *limdfsresources,
                      const GtUchar *pattern,
                      GtUword patternlength,
                      const AbstractDfstransformer *adfst)
{
  adfst->initdfsconstinfo(limdfsresources->dfsconstinfo,
                          (unsigned int) limdfsresources->alphasize,
                          pattern,
                          patternlength);
  runlimdfs(limdfsresources,adfst);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
movq (%rdi), %rdi
movzbl 0xc9(%r14), %esi
xorl %eax, %eax
callq *0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1bb5de
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbasedspacedseeds
void gt_indexbasedspacedseeds(Limdfsresources *limdfsresources,
                           const GtUchar *pattern,
                           GtBitsequence seedbitvector,
                           GtUword seedweight,
                           const AbstractDfstransformer *adfst)
{
  adfst->initdfsconstinfo(limdfsresources->dfsconstinfo,
                          (unsigned int) limdfsresources->alphasize,
                          pattern,
                          seedbitvector,
                          seedweight);
  runlimdfs(limdfsresources,adfst);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
movq (%rdi), %rdi
movzbl 0xc9(%r14), %esi
xorl %eax, %eax
callq *0x10(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1bb5de
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbasedlocali
void gt_indexbasedlocali(Limdfsresources *limdfsresources,
                      GtWord matchscore,
                      GtWord mismatchscore,
                      GtWord gapstart,
                      GtWord gapextend,
                      GtUword threshold,
                      const GtUchar *query,
                      GtUword querylength,
                      const AbstractDfstransformer *adfst)
{
  adfst->initdfsconstinfo(limdfsresources->dfsconstinfo,
                          (unsigned int) limdfsresources->alphasize,
                          matchscore,
                          mismatchscore,
                          gapstart,
                          gapextend,
                          threshold,
                          query,
                          querylength);
  runlimdfs(limdfsresources,adfst);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %r8, %rax
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x40(%rsp), %r14
movaps 0x30(%rsp), %xmm0
movq (%rdi), %rdi
movzbl 0xc9(%rbx), %esi
movups %xmm0, 0x8(%rsp)
movq %r9, (%rsp)
movq %rax, %r9
xorl %eax, %eax
callq *0x10(%r14)
movq %rbx, %rdi
movq %r14, %rsi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x1bb5de
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: genericmstats
GtUword genericmstats(const Limdfsresources *limdfsresources,
                            const GtUchar *qstart,
                            const GtUchar *qend)
{
  if (limdfsresources->genericindex->withesa)
  {
    return gt_suffixarraymstats (limdfsresources->genericindex->suffixarray,
                              0,
                              0,
                              limdfsresources->genericindex->totallength,
                              NULL,
                              qstart,
                              qend);
  }
  return gt_voidpackedindexmstatsforward(limdfsresources->genericindex->
                                                       packedindex,
                                      0,
                                      0,
                                      limdfsresources->genericindex->
                                                       totallength,
                                      NULL,
                                      qstart,
                                      qend);
}

// Assembly:
pushq %rax
movq %rsi, %r9
movq 0xd8(%rdi), %rax
cmpb $0x1, 0x18(%rax)
jne 0x1bb8a5
movq (%rax), %rdi
movq 0x8(%rax), %rcx
movq %rdx, (%rsp)
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x1ac5bb
popq %rcx
retq
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdi
movq %rdx, (%rsp)
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x1a8cdf
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbasedexactpatternmatching
bool gt_indexbasedexactpatternmatching(const Limdfsresources *limdfsresources,
                                    const GtUchar *pattern,
                                    GtUword patternlength)
{
  if (limdfsresources->genericindex->withesa)
  {
    return esa_exactpatternmatching(limdfsresources->genericindex->suffixarray,
                                    pattern,
                                    patternlength,
                                    limdfsresources->currentpathspace,
                                    limdfsresources->processmatch,
                                    limdfsresources->processmatchinfo);
  } else
  {
    return gt_pck_exactpatternmatching(
                                    limdfsresources->genericindex->packedindex,
                                    pattern,
                                    patternlength,
                                    limdfsresources->genericindex->totallength,
                                    limdfsresources->currentpathspace,
                                    limdfsresources->processmatch,
                                    limdfsresources->processmatchinfo);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rax
movq 0xd8(%rdi), %rdx
cmpb $0x1, 0x18(%rdx)
jne 0x1bb9a7
movq (%rdx), %r12
movq 0x130(%rax), %r13
movq 0x138(%rax), %rbx
movq (%r12), %rdi
callq 0xec1d8
movq (%r12), %rdi
movq 0x58(%r12), %rsi
movl 0x48(%r12), %r9d
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
pushq %r14
pushq %r15
callq 0x1ac81c
addq $0x10, %rsp
movq %rax, %r12
movq %rax, %rdi
callq 0x1ac92b
movl %eax, %ebp
movb $0x1, 0x10(%rsp)
movq %r14, 0x28(%rsp)
movq %r15, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq %r14, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1ac8f9
testb %al, %al
je 0x1bb993
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq *%r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x1ac8f9
testb %al, %al
jne 0x1bb971
movq %r12, %rdi
callq 0x1ac968
xorb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
jmp 0x1bb9d6
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %rdi
movq 0x118(%rax), %r8
movq 0x130(%rax), %r9
subq $0x8, %rsp
movq %r15, %rsi
movq %r14, %rdx
pushq 0x138(%rax)
callq 0x1a8d27
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: esa_exact_pattern_count
GtUword esa_exact_pattern_count(const Suffixarray *suffixarray,
                                      const GtUchar *pattern,
                                      GtUword patternlength) {
  GtMMsearchiterator *mmsi;
  GtUword count,
                totallength = gt_encseq_total_length(suffixarray->encseq);

  mmsi = gt_mmsearchiterator_new_complete_plain(suffixarray->encseq,
                                           suffixarray->suftab,
                                           0,  /* leftbound */
                                           totallength, /* rightbound */
                                           0, /* offset */
                                           suffixarray->readmode,
                                           pattern,
                                           patternlength);

  count = gt_mmsearchiterator_count(mmsi);
  gt_mmsearchiterator_delete(mmsi);
  return count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0xec1d8
movq (%r15), %rdi
movq 0x58(%r15), %rsi
movl 0x48(%r15), %r9d
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
pushq %rbx
pushq %r14
callq 0x1ac81c
addq $0x10, %rsp
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ac8db
movq %rax, %r14
movq %rbx, %rdi
callq 0x1ac968
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: currentparent
static const Lcpintervalwithinfo *currentparent(const Limdfsresources
                                                *limdfsresources)
{
  const Lcpintervalwithinfo *ptr;

  if (limdfsresources->keepexpandedonstack)
  {
    gt_assert(limdfsresources->parentindex <
              limdfsresources->stack.nextfreeLcpintervalwithinfo);
  }
  ptr = limdfsresources->keepexpandedonstack
           ? (limdfsresources->stack.spaceLcpintervalwithinfo +
              limdfsresources->parentindex)
           : &limdfsresources->copyofparent;
  return ptr;
}

// Assembly:
movb 0xc8(%rdi), %al
cmpb $0x1, %al
jne 0x1bbaf1
movq 0xc0(%rdi), %rcx
cmpq 0x30(%rdi), %rcx
jae 0x1bbaf9
testb %al, %al
je 0x1bbaf1
movq 0xc0(%rdi), %rax
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
addq 0x20(%rdi), %rax
movq %rax, %rdi
jmp 0x1bbaf5
addq $0x38, %rdi
movq %rdi, %rax
retq
pushq %rax
callq 0x66d47
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: allocateStackspace
static Lcpintervalwithinfo *allocateStackspace(Limdfsresources *limdfsresources,
                                               const AbstractDfstransformer
                                                      *adfst)
{
  GtArrayLcpintervalwithinfo *stack = &limdfsresources->stack;

  if (stack->nextfreeLcpintervalwithinfo >= stack->allocatedLcpintervalwithinfo)
  {
    GtUword idx;
    const GtUword addelems = 32UL;

    stack->spaceLcpintervalwithinfo
      = gt_realloc(stack->spaceLcpintervalwithinfo,
                   sizeof *stack->spaceLcpintervalwithinfo
                   * (stack->allocatedLcpintervalwithinfo + addelems));
    if (adfst->initLimdfsstackelem != NULL)
    {
      for (idx = stack->allocatedLcpintervalwithinfo;
           idx < stack->allocatedLcpintervalwithinfo + addelems; idx++)
      {
        adfst->initLimdfsstackelem(stack->spaceLcpintervalwithinfo[idx].
                                   aliasstate);
      }
    }
    stack->allocatedLcpintervalwithinfo += addelems;
  }
  return stack->spaceLcpintervalwithinfo + stack->nextfreeLcpintervalwithinfo++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq %rax, 0x30(%rdi)
jb 0x1bbee8
movq %rsi, %r14
movq 0x20(%rbx), %rdi
leaq (%rax,%rax,2), %rsi
shlq $0x5, %rsi
addq $0xc00, %rsi            # imm = 0xC00
leaq 0x1f4e5b(%rip), %rdx    # 0x3b0cf4
movl $0x151, %ecx            # imm = 0x151
callq 0x1094e6
movq %rax, 0x20(%rbx)
cmpq $0x0, 0x30(%r14)
je 0x1bbee3
movq 0x28(%rbx), %r15
cmpq $-0x21, %r15
ja 0x1bbee3
leaq (%r15,%r15,2), %r12
shlq $0x5, %r12
addq $0x28, %r12
movq 0x20(%rbx), %rdi
addq %r12, %rdi
callq *0x30(%r14)
incq %r15
movq 0x28(%rbx), %rax
addq $0x20, %rax
addq $0x60, %r12
cmpq %rax, %r15
jb 0x1bbec4
addq $0x20, 0x28(%rbx)
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
leaq (%rax,%rax,2), %rax
shlq $0x5, %rax
addq 0x20(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: tracethestackelems
static void tracethestackelems(GtIdxMatch *match,
                               Limdfsresources *limdfsresources,
                               GtUword pprefixlen,
                               const Lcpintervalwithinfo *runptr)
{
  GtUword previous = 0;

  gt_assert(runptr != NULL);
  gt_reinitLocaliTracebackstate(limdfsresources->dfsconstinfo,
                                runptr->lcpitv.offset,
                                pprefixlen);
  do
  {
    if (previous > 0)
    {
      gt_assert(previous - 1 == runptr->lcpitv.offset);
    }
    previous = runptr->lcpitv.offset;
    gt_assert(previous > 0);
    gt_assert(runptr->previousstackelem <
              limdfsresources->stack.nextfreeLcpintervalwithinfo);
    gt_processelemLocaliTracebackstate(limdfsresources->dfsconstinfo,
                                    runptr->lcpitv.inchar,runptr->aliasstate);
    runptr = limdfsresources->stack.spaceLcpintervalwithinfo +
             runptr->previousstackelem;
  } while (runptr->lcpitv.offset > 0);
  match->alignment
    = gt_completealignmentfromLocaliTracebackstate(&match->querylen,
                                                limdfsresources->dfsconstinfo);
  gt_assert(pprefixlen >= match->querylen);
  match->querystartpos = pprefixlen - match->querylen;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rcx, %rcx
je 0x1bc63d
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rdi
movq (%rcx), %rsi
callq 0x1bce58
xorl %r13d, %r13d
testq %r13, %r13
je 0x1bc5c7
decq %r13
cmpq (%r12), %r13
jne 0x1bc638
movq (%r12), %r13
testq %r13, %r13
je 0x1bc62e
movq 0x58(%r12), %rax
cmpq 0x30(%r15), %rax
jae 0x1bc633
movq (%r15), %rdi
movzbl 0x20(%r12), %esi
leaq 0x28(%r12), %rdx
callq 0x1bce95
movq 0x20(%r15), %rax
movq 0x58(%r12), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x5, %rcx
leaq (%rax,%rcx), %r12
cmpq $0x0, (%rax,%rcx)
jne 0x1bc5b9
leaq 0x30(%r14), %rdi
movq (%r15), %rsi
callq 0x1bcf6e
movq %rax, 0x40(%r14)
subq 0x30(%r14), %rbx
jb 0x1bc642
movq %rbx, 0x28(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x66f81
callq 0x66f0f
callq 0x66ed6
callq 0x66fba
callq 0x66f48
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: esa_overinterval
static void esa_overinterval(Limdfsresources *limdfsresources,
                             const Indexbounds *itv,
                             GtIdxMatch *match)
{
  gen_esa_overinterval(limdfsresources->genericindex,
                       limdfsresources->processmatch,
                       limdfsresources->processmatchinfo,
                       itv,
                       limdfsresources->genericindex->totallength,
                       match);
  limdfsresources->numberofmatches += (itv->rightbound - itv->leftbound + 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, (%rsp)
movq 0x8(%rsi), %r13
cmpq 0x10(%rsi), %r13
ja 0x1bc6a0
movq %rdx, %r15
movq (%rsp), %rax
movq 0xd8(%rax), %rbp
movq 0x130(%rax), %rbx
movq 0x138(%rax), %r12
movq (%rbp), %rax
movq 0x58(%rax), %rax
movq (%rax,%r13,8), %rax
movq %rax, 0x10(%r15)
movq %r12, %rdi
movq %r15, %rsi
callq *%rbx
incq %r13
cmpq 0x10(%r14), %r13
jbe 0x1bc67f
movq 0x10(%r14), %rax
movq (%rsp), %rdx
movq 0x128(%rdx), %rcx
subq 0x8(%r14), %rax
addq %rcx, %rax
incq %rax
movq %rax, 0x128(%rdx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: pck_overinterval
static void pck_overinterval(Limdfsresources *limdfsresources,
                             const Indexbounds *itv,
                             GtIdxMatch *match)
{
  gen_pck_overinterval(limdfsresources->genericindex,
                       limdfsresources->processmatch,
                       limdfsresources->processmatchinfo,
                       itv,
                       limdfsresources->genericindex->totallength,
                       match);
  limdfsresources->numberofmatches += (itv->rightbound - itv->leftbound);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r9
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd8(%rdi), %rdi
movq 0x130(%r14), %rsi
movq 0x138(%r14), %rdx
movq 0x8(%rdi), %r8
movq %rbx, %rcx
callq 0x1bb498
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq %rax, 0x128(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/idx-limdfs.c
// Function: expandsingleton
static Lcpintervalwithinfo *expandsingleton(Limdfsresources *limdfsresources,
                                            GtUword *resetvalue,
                                            bool notfirst,
                                            GtUchar cc,
                                            GtUword currentdepth,
                                            const AbstractDfstransformer *adfst)
{
  if (limdfsresources->keepexpandedonstack)
  {
    Lcpintervalwithinfo *instate;
    Lcpintervalwithinfo *outstate;

    outstate = allocateStackspace(limdfsresources,adfst);
    outstate->keeponstack = true;
    outstate->lcpitv.offset = (GtUword) currentdepth;
    outstate->lcpitv.inchar = cc;
    if (notfirst)
    {
      instate = outstate-1;
      gt_assert(limdfsresources->stack.nextfreeLcpintervalwithinfo >= 2UL);
      outstate->previousstackelem
        = limdfsresources->stack.nextfreeLcpintervalwithinfo - 2;
    } else
    {
      gt_assert(limdfsresources->parentindex <
                limdfsresources->stack.nextfreeLcpintervalwithinfo-1);
      *resetvalue = limdfsresources->stack.nextfreeLcpintervalwithinfo-1;
      instate = limdfsresources->stack.spaceLcpintervalwithinfo +
                limdfsresources->parentindex;
      outstate->previousstackelem = limdfsresources->parentindex;
    }
    gt_assert(instate < outstate);
    adfst->nextLimdfsstate(limdfsresources->dfsconstinfo,
                           outstate->aliasstate,
                           currentdepth,
                           cc,
                           instate->aliasstate);
    return outstate;
  }
  adfst->inplacenextLimdfsstate(limdfsresources->dfsconstinfo,
                                limdfsresources->copyofcopyofparentstate,
                                currentdepth,
                                cc);
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movl %ecx, %ebp
movq %rdi, %r12
cmpb $0x1, 0xc8(%rdi)
jne 0x1bc76f
movl %edx, %ebx
movq %rsi, %r13
movq %r12, %rdi
movq %r9, (%rsp)
movq %r9, %rsi
callq 0x1bbe67
movq %rax, %r15
movb $0x1, 0x50(%rax)
movq %r14, (%rax)
movb %bpl, 0x20(%rax)
testb %bl, %bl
je 0x1bc78d
movq 0x30(%r12), %rax
cmpq $0x1, %rax
jbe 0x1bc7f5
leaq -0x60(%r15), %r8
addq $-0x2, %rax
jmp 0x1bc7b8
movq (%r12), %rdi
addq $0x98, %r12
movzbl %bpl, %ecx
movq %r12, %rsi
movq %r14, %rdx
callq *0x58(%r9)
xorl %r15d, %r15d
jmp 0x1bc7de
movq 0x30(%r12), %rax
decq %rax
cmpq %rax, 0xc0(%r12)
jae 0x1bc7fa
movq %rax, (%r13)
movq 0xc0(%r12), %rax
leaq (%rax,%rax,2), %r8
shlq $0x5, %r8
addq 0x20(%r12), %r8
movq %rax, 0x58(%r15)
cmpq %r15, %r8
jae 0x1bc7f0
movq (%r12), %rdi
movq %r15, %rsi
addq $0x28, %rsi
addq $0x28, %r8
movzbl %bpl, %ecx
movq %r14, %rdx
movq (%rsp), %rax
callq *0x50(%rax)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x67065
callq 0x6702c
callq 0x66ff3
nop