LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1b029a
movq %rdx, %rax
movq %rsi, %r10
movq %rdi, %rdx
movq (%rdi), %rdi
movl 0x10(%rdx), %edx
testl %edx, %edx
je 0x1b0269
cmpl $0x1, %edx
jne 0x1b029f
leaq 0x1a359d(%rip), %rdx    # 0x353804
jmp 0x1b0270
leaq 0x1a3582(%rip), %rdx    # 0x3537f2
movzbl %cl, %r9d
orl $0x30, %r9d
movzbl %r8b, %ecx
orl $0x30, %ecx
movl %ecx, (%rsp)
leaq 0x1f6dcf(%rip), %rsi    # 0x3a7058
movq %r10, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0xfee51
xorl %eax, %eax
popq %rcx
retq
callq 0x64d2f
callq 0x64cf8
// File: /workspace/github_c_makefile_star2_O3/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 0xeb9d2
movq %rax, %rbx
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xeb9d2
movq %rax, %r10
movl 0x10(%r14), %eax
movq (%r14), %rdi
cmpl $0x1, %eax
je 0x1b04d0
movq (%rsp), %rdx
testl %eax, %eax
jne 0x1b055c
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 0x1f6c47(%rip), %rsi    # 0x3a7102
movq %r15, %r8
xorl %eax, %eax
pushq %r12
callq 0xfee51
addq $0x18, %rsp
jmp 0x1b0551
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 0x1bcc86(%rip), %r15    # 0x36d183
leaq 0x219c6c(%rip), %rsi    # 0x3ca170
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 0x1f6be4(%rip), %rsi    # 0x3a7118
movq 0x8(%rsp), %rdx
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r10
pushq %r14
pushq %r13
pushq %rbx
pushq %r11
callq 0xfee51
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x64d9d
// File: /workspace/github_c_makefile_star2_O3/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 0x1b0b0a
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1b0b76
xorl %eax, %eax
xorl %ecx, %ecx
movzbl (%rbx,%rax), %edx
cmpl $0x7c, %edx
je 0x1b0b1d
testl %edx, %edx
jne 0x1b0b2a
jmp 0x1b0b2f
testq %rcx, %rcx
jne 0x1b0b48
movq %rax, %rcx
testq %rax, %rax
je 0x1b0b71
incq %rax
jmp 0x1b0b0e
leaq 0x1f684c(%rip), %rsi    # 0x3a7382
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xfcb67
jmp 0x1b0b62
testq %rax, %rax
je 0x1b0b7b
cmpq %rax, %rcx
jae 0x1b0b80
leaq (%rbx,%rcx), %r12
incq %r12
notq %rcx
addq %rax, %rcx
movq %rcx, (%r14)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x64fd7
callq 0x64f2c
callq 0x64f9e
callq 0x64f65
// File: /workspace/github_c_makefile_star2_O3/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 0xec19e
movq %rax, %rbp
movl $0x3e, %edi
movq %r15, %rsi
callq 0x11f81a
testq %r12, %r12
je 0x1b0bec
movq 0x8(%r12), %rdx
movq 0x10(%r12), %rcx
movq %rdx, %rax
xorq $0x1, %rax
orq %rcx, %rax
je 0x1b0bec
movq (%r12), %rsi
leaq 0x1f67d8(%rip), %rdi    # 0x3a73bd
xorl %eax, %eax
callq 0x17070
movq (%rsp), %rdx
movl $0x1, %esi
movq %rbp, %rdi
movq %r15, %rcx
callq 0x11f89c
movl $0xa, %edi
movq %r15, %rsi
callq 0x11f81a
movq %r14, %rdi
movq %r13, %rsi
callq 0xeb6ee
movq %rax, %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0xeb9d2
testq %r12, %r12
je 0x1b0c41
movq 0x8(%r12), %rcx
movq 0x10(%r12), %rdx
movq %rcx, %rsi
xorq $0x1, %rsi
orq %rdx, %rsi
jne 0x1b0c45
xorl %ecx, %ecx
jmp 0x1b0c51
subq %rcx, %rdx
decq %rcx
incq %rdx
movq %rdx, %rax
addq %rbp, %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %r8
movq %rbx, %r9
callq 0x198b2f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/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 0x1b185a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1b183b
leaq 0x1f5924(%rip), %r15    # 0x3a7142
movq %rbx, %r12
movq (%r12), %rdi
movq %r15, %rsi
movl $0x9f, %edx
callq 0x1045eb
addq $0x20, %r12
decq %r14
jne 0x1b1821
leaq 0x1f5900(%rip), %rsi    # 0x3a7142
movq %rbx, %rdi
movl $0xa1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/giextract.c
// Function: comparefastakeys
static int comparefastakeys(const void *a,const void *b)
{
  int cmp = strcmp(((Fastakeyquery *) a)->fastakey,
                   ((Fastakeyquery *) b)->fastakey);

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x17a40
testl %eax, %eax
jns 0x1b1a4f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x1b1a56
movl $0x1, %eax
je 0x1b1a5e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rcx
cmpq %rcx, 0x8(%rbx)
jb 0x1b1a48
ja 0x1b1a56
movq 0x10(%r14), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, 0x10(%rbx)
jb 0x1b1a56
seta %al
movzbl %al, %eax
jmp 0x1b1a56
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x1f5b9d(%rip), %r14    # 0x3a7630
movl $0x28, %edi
movq %r14, %rsi
movl $0x3c, %edx
callq 0x104226
movq %rax, %r15
imulq %rbx, %rbx
movq %rbx, (%rax)
shlq $0x3, %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x40, %edx
callq 0x104226
movq %rax, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b2294
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1a1540
movq (%rbx), %rdi
leaq 0x1f54d1(%rip), %rsi    # 0x3a7738
movl $0x37, %edx
callq 0x1045eb
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1b227f
callq 0x1a0035
leaq 0x1f54b2(%rip), %rsi    # 0x3a7738
movq %rbx, %rdi
movl $0x3c, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b267a
leaq 0x8(%r14), %r12
leaq 0x1f50d9(%rip), %rsi    # 0x3a7738
movl $0x17f, %edx            # imm = 0x17F
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
cmpq $0x0, 0x38(%r15)
je 0x1b26c6
cmpq $0x0, 0x28(%r14)
je 0x1b26a9
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 0x1b2691
cmpb $0x0, 0xc8(%r14)
jne 0x1b26c6
leaq 0x98(%r14), %rdi
callq *0x38(%r15)
leaq 0x60(%r14), %rdi
callq *0x38(%r15)
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x1b26f3
leaq 0x20(%r14), %r15
leaq 0x1f505e(%rip), %rsi    # 0x3a7738
movl $0x190, %edx            # imm = 0x190
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq 0xf0(%r14), %rdi
leaq 0x1f5037(%rip), %r15    # 0x3a7738
movq %r15, %rsi
movl $0x191, %edx            # imm = 0x191
callq 0x1045eb
movq 0x118(%r14), %rdi
movq %r15, %rsi
movl $0x192, %edx            # imm = 0x192
callq 0x1045eb
movq 0x100(%r14), %rdi
testq %rdi, %rdi
je 0x1b2755
addq $0x100, %r14            # imm = 0x100
leaq 0x1f4ffc(%rip), %rsi    # 0x3a7738
movl $0x193, %edx            # imm = 0x193
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq (%rbx), %rdi
leaq 0x1f4fd9(%rip), %rsi    # 0x3a7738
movl $0x194, %edx            # imm = 0x194
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1045eb
// File: /workspace/github_c_makefile_star2_O3/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 0x1b286f
movq %rdi, %r14
movq 0xd8(%rdi), %rdi
testq %rdi, %rdi
je 0x1b286f
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        # 0x1b2874
cmpb $0x0, 0x18(%rdi)
leaq 0xd0(%rip), %r10        # 0x1b28c9
cmovneq %rcx, %r10
movq 0x8(%rdi), %r8
leaq 0x148(%rip), %rsi       # 0x1b2950
movq %r12, %rdx
movq %rax, %rcx
callq *%r10
movq 0x100(%r14), %rdi
movq 0x110(%r14), %rsi
leaq 0x190(%rip), %rcx       # 0x1b29b6
movl $0x8, %edx
callq 0x17f60
movq 0xd8(%r14), %rax
cmpb $0x1, 0x18(%rax)
jne 0x1b2856
movq 0x128(%r14), %rax
subq %r15, %rbx
addq %rbx, %rax
incq %rax
movq %rax, 0x128(%r14)
jmp 0x1b2860
subq %r15, %rbx
addq %rbx, 0x128(%r14)
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x6534e
// File: /workspace/github_c_makefile_star2_O3/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 0x1b28ba
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 0x1b2898
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/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 0x1b294b
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq 0x10(%rdi), %rdi
callq 0x19f96f
movq %rax, %rbp
movq %rsp, %rdi
movq %rax, %rsi
callq 0x19f9bb
testb %al, %al
je 0x1b292f
movq (%r15), %rcx
addq (%rsp), %rcx
movq %r14, %rax
subq %rcx, %rax
jb 0x1b2946
movq %rax, 0x10(%rbx)
movq %r12, %rdi
movq %rbx, %rsi
callq *%r13
movq %rsp, %rdi
movq %rbp, %rsi
jmp 0x1b2902
movq %rbp, %rdi
callq 0x19fa8c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x653c0
callq 0x65387
// File: /workspace/github_c_makefile_star2_O3/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 0x1b2cf8
movq (%rax), %rdi
movq 0x8(%rax), %rcx
movq %rdx, (%rsp)
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x1a3bd0
popq %rcx
retq
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdi
movq %rdx, (%rsp)
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x1a0510
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b2dfa
movq (%rdx), %r12
movq 0x130(%rax), %r13
movq 0x138(%rax), %rbx
movq (%r12), %rdi
callq 0xe7b9c
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 0x1a3e08
addq $0x10, %rsp
movq %rax, %r12
movq %rax, %rdi
callq 0x1a3f17
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 0x1a3ee5
testb %al, %al
je 0x1b2de6
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 0x1a3ee5
testb %al, %al
jne 0x1b2dc4
movq %r12, %rdi
callq 0x1a3f54
xorb $0x1, %bpl
movl %ebp, %eax
addq $0x58, %rsp
jmp 0x1b2e29
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 0x1a0558
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/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 0xe7b9c
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 0x1a3e08
addq $0x10, %rsp
movq %rax, %rbx
movq %rax, %rdi
callq 0x1a3ec7
movq %rax, %r14
movq %rbx, %rdi
callq 0x1a3f54
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30(%rdi), %rcx
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rdx
cmpq %rdx, %rcx
jb 0x1b334f
movq %rsi, %r14
leaq (%rdx,%rdx,2), %rsi
shlq $0x5, %rsi
addq $0xc00, %rsi            # imm = 0xC00
leaq 0x1f4454(%rip), %rdx    # 0x3a7738
movq %rax, %rdi
movl $0x151, %ecx            # imm = 0x151
callq 0x104461
movq %rax, 0x20(%rbx)
cmpq $0x0, 0x30(%r14)
setne %cl
movq 0x28(%rbx), %r15
cmpq $-0x20, %r15
setb %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x1b3340
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), %rcx
leaq 0x20(%rcx), %rax
addq $0x60, %r12
cmpq %rax, %r15
jb 0x1b331b
movq 0x20(%rbx), %rax
jmp 0x1b3343
movq %r15, %rcx
addq $0x20, %rcx
movq %rcx, 0x28(%rbx)
movq 0x30(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x30(%rbx)
leaq (%rcx,%rcx,2), %rcx
shlq $0x5, %rcx
addq %rax, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1b3a9a
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rdi
movq (%rcx), %rsi
callq 0x1b42b0
xorl %r13d, %r13d
testq %r13, %r13
je 0x1b3a24
decq %r13
cmpq (%r12), %r13
je 0x1b3a28
jmp 0x1b3a95
movq (%r12), %r13
testq %r13, %r13
je 0x1b3a8b
movq 0x58(%r12), %rax
cmpq 0x30(%r15), %rax
jae 0x1b3a90
movq (%r15), %rdi
movzbl 0x20(%r12), %esi
leaq 0x28(%r12), %rdx
callq 0x1b42ed
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 0x1b3a14
leaq 0x30(%r14), %rdi
movq (%r15), %rsi
callq 0x1b43c7
movq %rax, 0x40(%r14)
subq 0x30(%r14), %rbx
jb 0x1b3a9f
movq %rbx, 0x28(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x657c2
callq 0x65750
callq 0x65717
callq 0x657fb
callq 0x65789
// File: /workspace/github_c_makefile_star2_O3/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 0x1b28c9
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_O3/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 %r9, %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdi, %r12
cmpb $0x1, 0xc8(%rdi)
jne 0x1b3bd3
movl %edx, %r13d
movq %rsi, (%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1b32ab
movq %rax, %r15
movb $0x1, 0x50(%rax)
movq %r14, (%rax)
movb %bpl, 0x20(%rax)
testb %r13b, %r13b
je 0x1b3bf0
movq 0x30(%r12), %rax
cmpq $0x1, %rax
jbe 0x1b3c52
leaq -0x60(%r15), %r8
addq $-0x2, %rax
movq %rax, 0x58(%r15)
jmp 0x1b3c27
movq (%r12), %rdi
addq $0x98, %r12
movzbl %bpl, %ecx
movq %r12, %rsi
movq %r14, %rdx
callq *0x58(%rbx)
xorl %r15d, %r15d
jmp 0x1b3c40
movq 0x30(%r12), %rax
decq %rax
cmpq %rax, 0xc0(%r12)
jae 0x1b3c57
movq (%rsp), %rcx
movq %rax, (%rcx)
movq 0xc0(%r12), %rax
leaq (%rax,%rax,2), %r8
shlq $0x5, %r8
addq 0x20(%r12), %r8
movq %rax, 0x58(%r15)
cmpq %r15, %r8
jae 0x1b3c5c
movq (%r12), %rdi
movq %r15, %rsi
addq $0x28, %rsi
addq $0x28, %r8
movzbl %bpl, %ecx
movq %r14, %rdx
callq *0x50(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x658a6
callq 0x65834
callq 0x6586d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocali.c
// Function: gt_checkandresetstorematch
void gt_checkandresetstorematch(GT_UNUSED uint64_t queryunit,
                             Storematchinfo *storeonline,
                             Storematchinfo *storeoffline)
{
  GtUword seqnum, countmatchseq = 0,
    numofdbsequences = gt_encseq_num_of_sequences(storeonline->encseq);

  for (seqnum = 0; seqnum < numofdbsequences; seqnum++)
  {
#ifndef NDEBUG
    if (GT_ISIBITSET(storeonline->hasmatch,seqnum) &&
        !GT_ISIBITSET(storeoffline->hasmatch,seqnum))
    {
      fprintf(stderr,"query " Formatuint64_t " refseq "GT_WU": "
                     "online has match but offline not\n",
                     PRINTuint64_tcast(queryunit),seqnum);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    if (!GT_ISIBITSET(storeonline->hasmatch,seqnum) &&
        GT_ISIBITSET(storeoffline->hasmatch,seqnum))
    {
      fprintf(stderr,"query " Formatuint64_t " refseq "GT_WU": "
                     "offline has match but online not\n",
                     PRINTuint64_tcast(queryunit),seqnum);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
#endif
    if (GT_ISIBITSET(storeonline->hasmatch,seqnum))
    {
      countmatchseq++;
    }
  }
  GT_CLEARBITTAB(storeonline->hasmatch,numofdbsequences);
  GT_CLEARBITTAB(storeoffline->hasmatch,numofdbsequences);
  printf("matching sequences: "GT_WU"\n",countmatchseq);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdi
callq 0xe7bac
movq 0x8(%r14), %rdi
testq %rax, %rax
je 0x1b3d31
movq 0x8(%rbx), %rdx
xorl %ecx, %ecx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorl %r14d, %r14d
movq %rcx, %r10
movq %rsi, %r8
shrq %cl, %r8
shrq $0x6, %r10
movq (%rdi,%r10,8), %r9
movq (%rdx,%r10,8), %r10
testq %r8, %r9
je 0x1b3d17
testq %r8, %r10
jne 0x1b3d1c
jmp 0x1b3d80
testq %r8, %r10
jne 0x1b3d8b
andq %r8, %r9
cmpq $0x1, %r9
sbbq $-0x1, %r14
incq %rcx
cmpq %rcx, %rax
jne 0x1b3cf6
jmp 0x1b3d34
xorl %r14d, %r14d
leaq -0x1(%rax), %rcx
shrq $0x6, %rcx
cmpq $0x40, %rax
leaq 0x8(,%rcx,8), %rax
movl $0x8, %r15d
cmovaeq %rax, %r15
xorl %esi, %esi
movq %r15, %rdx
callq 0x173a0
movq 0x8(%rbx), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x173a0
leaq 0x1f416e(%rip), %rdi    # 0x3a7edf
movq %r14, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x17070
movq %r15, %rdi
movq %rcx, %rsi
callq 0x65906
movq %r15, %rdi
movq %rcx, %rsi
callq 0x658df
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocali.c
// Function: storematch
static void storematch(void *info,const GtIdxMatch *match)
{
  Storematchinfo *storematch = (Storematchinfo *) info;
  GtUword seqnum;

  if (match->dbabsolute)
  {
    seqnum = gt_encseq_seqnum(storematch->encseq,
                                           match->dbstartpos);
  } else
  {
    seqnum = match->dbseqnum;
  }
  if (!GT_ISIBITSET(storematch->hasmatch,seqnum))
  {
    GT_SETIBIT(storematch->hasmatch,seqnum);
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x1b41cd
movq (%rbx), %rdi
movq 0x10(%rsi), %rsi
callq 0xeb655
movq %rax, %rcx
jmp 0x1b41d1
movq 0x8(%rsi), %rcx
movq 0x8(%rbx), %rax
movq %rcx, %rdx
shrq $0x6, %rdx
movq (%rax,%rdx,8), %rsi
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
shrq %cl, %rdi
testq %rdi, %rsi
jne 0x1b41f9
orq %rdi, %rsi
movq %rsi, (%rax,%rdx,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocali.c
// Function: idxlocali_showmatch
static void idxlocali_showmatch(void *processinfo,const GtIdxMatch *match)
{
  Showmatchinfo *showmatchinfo = (Showmatchinfo *) processinfo;
  GtUword seqnum;
  GtUword relpos;

  if (match->dbabsolute)
  {
    GtUword seqstartpos;
    seqnum = gt_encseq_seqnum(showmatchinfo->encseq, match->dbstartpos);
    seqstartpos = gt_encseq_seqstartpos(showmatchinfo->encseq, seqnum);
    gt_assert(seqstartpos <= match->dbstartpos);
    relpos = match->dbstartpos - seqstartpos;
  } else
  {
    relpos = match->dbstartpos;
    seqnum = match->dbseqnum;
  }
  printf(""GT_WU"\t"GT_WU"\t",seqnum,relpos);
  printf(""GT_WU"\t",match->dblen);
  printf("\t" Formatuint64_t "\t"GT_WU"\t"GT_WU"\t"GT_WU"\n",
              PRINTuint64_tcast(showmatchinfo->queryunit),
              match->querystartpos,
              match->querylen,
              match->distance);
  if (showmatchinfo->showalignment)
  {
    gt_alignment_show_with_mapped_chars(
                (const GtAlignment *) match->alignment,
                showmatchinfo->characters,
                showmatchinfo->wildcardshow,
                stdout,
                70);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x1b4235
movq 0x18(%rbx), %rdi
movq 0x10(%r14), %rsi
callq 0xeb655
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0xeb6ee
movq 0x10(%r14), %rdx
subq %rax, %rdx
jae 0x1b423d
callq 0x65966
movq 0x8(%r14), %r15
movq 0x10(%r14), %rdx
leaq 0x229c44(%rip), %rdi    # 0x3dde88
movq %r15, %rsi
xorl %eax, %eax
callq 0x17070
movq 0x18(%r14), %rsi
leaq 0x1f75ef(%rip), %rdi    # 0x3ab848
xorl %eax, %eax
callq 0x17070
movq 0x8(%rbx), %rsi
movq 0x28(%r14), %rdx
movq 0x30(%r14), %rcx
movq 0x38(%r14), %r8
leaq 0x19c679(%rip), %rdi    # 0x3508f0
xorl %eax, %eax
callq 0x17070
cmpb $0x1, 0x11(%rbx)
jne 0x1b42a9
movq 0x40(%r14), %rdi
movq (%rbx), %rsi
movzbl 0x10(%rbx), %edx
movq 0x304c42(%rip), %rax    # 0x4b8ed8
movq (%rax), %rcx
movl $0x46, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x121da5
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocalidp.c
// Function: gt_reinitLocaliTracebackstate
void gt_reinitLocaliTracebackstate(Limdfsconstinfo *lci,
                                GtUword dbprefixlen,
                                GtUword pprefixlen)
{
  LocaliTracebackstate *tbs = &lci->tbs;

  tbs->dbprefixlen = tbs->dbcurrent = dbprefixlen;
  tbs->queryend = tbs->querypos = pprefixlen;
  if (dbprefixlen > (GtUword) tbs->allocatedGtUchardbsubstring)
  {
    tbs->spaceGtUchardbsubstring = gt_realloc(tbs->spaceGtUchardbsubstring,
                                            sizeof (GtUchar) * dbprefixlen);
  }
  gt_alignment_reset(tbs->alignment);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x40(%rdi)
movq %rsi, 0x48(%rdi)
movq %rdx, 0x50(%rdi)
movq %rdx, 0x58(%rdi)
cmpq %rsi, 0x68(%rdi)
jae 0x1b42e3
movq 0x60(%rbx), %rdi
leaq 0x1f3c8c(%rip), %rdx    # 0x3a7f61
movl $0x2b0, %ecx            # imm = 0x2B0
callq 0x104461
movq %rax, 0x60(%rbx)
movq 0x70(%rbx), %rdi
popq %rbx
jmp 0x120f84
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocalidp.c
// Function: gt_processelemLocaliTracebackstate
void gt_processelemLocaliTracebackstate(Limdfsconstinfo *lci,
                                     GtUchar currentchar,
                                     const void *aliasstate)
{
  LocaliTracebackstate *tbs = &lci->tbs;
  const LocaliColumn *column = (const LocaliColumn *) aliasstate;

  while (true)
  {
    /*
    printf(" coord(i="GT_WU",j="GT_WU") with ",tbs->querypos,
                                       (GtUword) tbs->dbcurrent);
    printf("cellvalue="GT_WD", ",column->colvalues[tbs->querypos].bestcell);
    */
    switch (column->colvalues[tbs->querypos].tracebit)
    {
      case Insertbit:
        /* printf("insertbit\n"); */
        gt_alignment_add_insertion(tbs->alignment);
        gt_assert(tbs->dbcurrent > 0);
        tbs->dbcurrent--;
        tbs->spaceGtUchardbsubstring[tbs->dbcurrent] = currentchar;
        return;
      case Replacebit:
        /* printf("replacebit\n"); */
        gt_alignment_add_replacement(tbs->alignment);
        gt_assert(tbs->dbcurrent > 0);
        tbs->dbcurrent--;
        tbs->spaceGtUchardbsubstring[tbs->dbcurrent] = currentchar;
        gt_assert(tbs->querypos > 0);
        tbs->querypos--;
        return;
      case Deletebit:
        /* printf("deletebit\n"); */
        gt_alignment_add_deletion(tbs->alignment);
        gt_assert(tbs->querypos > 0);
        tbs->querypos--;
        break; /* stay in the same column => so next iteration */
      case Notraceback:
        fprintf(stderr,"tracebit = Notraceback not allowed\n");
        fprintf(stderr,"column->colvalues[tbs->querypos].bestcell="GT_WD"\n",
                        column->colvalues[tbs->querypos].bestcell);
        exit(GT_EXIT_PROGRAMMING_ERROR);
      default:
        fprintf(stderr,"tracebit = %d not allowed\n",
                (int) column->colvalues[tbs->querypos].tracebit);
        exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
leaq 0x50(%rdi), %r15
movq 0x50(%rdi), %rax
movq (%r12), %rcx
shlq $0x4, %rax
movl 0x8(%rcx,%rax), %edi
cmpl $0x3, %edi
jne 0x1b4334
movq 0x70(%r14), %rdi
callq 0x120f4a
movq 0x50(%r14), %rax
testq %rax, %rax
je 0x1b43b3
decq %rax
movq %rax, (%r15)
jmp 0x1b4305
cmpl $0x1, %edi
je 0x1b4371
cmpl $0x2, %edi
jne 0x1b439f
movq 0x70(%r14), %rdi
callq 0x120f2d
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x1b43b8
leaq -0x1(%rax), %rcx
movq %rcx, 0x40(%r14)
movq 0x60(%r14), %rcx
movb %bl, -0x1(%rcx,%rax)
movq 0x50(%r14), %rax
testq %rax, %rax
je 0x1b43c2
decq %rax
movq %rax, (%r15)
jmp 0x1b4393
movq 0x70(%r14), %rdi
callq 0x120f67
movq 0x40(%r14), %rax
testq %rax, %rax
je 0x1b43bd
leaq -0x1(%rax), %rcx
movq %rcx, 0x40(%r14)
movq 0x60(%r14), %rcx
movb %bl, -0x1(%rcx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testl %edi, %edi
jne 0x1b43ae
movq %r12, %rdi
movq %r15, %rsi
callq 0x6599d
callq 0x65acf
callq 0x659eb
callq 0x65a5d
callq 0x65a96
callq 0x65a24
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_allocatedfsconstinfo
static Limdfsconstinfo *locali_allocatedfsconstinfo (GT_UNUSED
                                                     unsigned int alphasize)
{
  Limdfsconstinfo *lci;

  lci = gt_malloc (sizeof (Limdfsconstinfo));
  lci->maxcollen = 0;
  lci->tbs.alignment = gt_alignment_new();
  lci->tbs.spaceGtUchardbsubstring = NULL;
  lci->tbs.allocatedGtUchardbsubstring = 0;
  return lci;
}

// Assembly:
pushq %rbx
leaq 0x1f3b22(%rip), %rsi    # 0x3a7f61
movl $0x78, %edi
movl $0x1ea, %edx            # imm = 0x1EA
callq 0x104226
movq %rax, %rbx
movq $0x0, 0x28(%rax)
callq 0x120d2c
movq %rax, 0x70(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_initdfsconstinfo
static void locali_initdfsconstinfo (Limdfsconstinfo *lci,
                                     unsigned int alphasize,...)
{
  va_list ap;

  va_start (ap, alphasize);
  lci->scorevalues.matchscore = va_arg (ap, Scoretype);
  lci->scorevalues.mismatchscore = va_arg (ap, Scoretype);
  lci->scorevalues.gapstart = va_arg (ap, Scoretype);
  lci->scorevalues.gapextend = va_arg (ap, Scoretype);
  lci->threshold = va_arg (ap, GtUword);
  lci->query = va_arg (ap, const GtUchar *);
  lci->querylength = va_arg (ap, GtUword);
  if (lci->maxcollen < lci->querylength + 1)
  {
    lci->maxcollen = lci->querylength+1;
  }
  va_end(ap);
}

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x1b44b2
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %rsi, -0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
movl $0x10, %eax
cmpq $0x29, %rax
jae 0x1b457c
movq -0x70(%rsp), %rdx
leaq 0x8(%rax), %rcx
movl %ecx, -0x80(%rsp)
movq (%rdx,%rax), %rdx
movq %rdx, (%rdi)
cmpl $0x21, %eax
jae 0x1b4590
movq -0x70(%rsp), %rsi
leaq 0x10(%rax), %rdx
movl %edx, -0x80(%rsp)
movq (%rsi,%rcx), %rcx
movq %rcx, 0x8(%rdi)
cmpl $0x19, %eax
jae 0x1b45a5
movq -0x70(%rsp), %rcx
leaq 0x18(%rax), %rsi
movl %esi, -0x80(%rsp)
movq (%rcx,%rdx), %rcx
movq %rcx, 0x10(%rdi)
cmpl $0x11, %eax
jae 0x1b45ba
movq -0x70(%rsp), %rdx
leaq 0x20(%rax), %rcx
movl %ecx, -0x80(%rsp)
movq (%rdx,%rsi), %rdx
movq %rdx, 0x18(%rdi)
cmpl $0x29, %ecx
jae 0x1b45cf
movq -0x70(%rsp), %rsi
leal 0x28(%rax), %edx
movl %edx, -0x80(%rsp)
movq (%rsi,%rcx), %rcx
movq %rcx, 0x38(%rdi)
testq %rax, %rax
jne 0x1b45e4
movl %edx, %eax
addq -0x70(%rsp), %rax
movl $0x30, -0x80(%rsp)
jmp 0x1b45f2
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, (%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x38(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x20(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x30(%rdi)
incq %rax
cmpq %rax, 0x28(%rdi)
jae 0x1b461b
movq %rax, 0x28(%rdi)
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_freedfsconstinfo
static void locali_freedfsconstinfo (Limdfsconstinfo **lci)
{
  gt_alignment_delete((*lci)->tbs.alignment);
  (*lci)->tbs.alignment = NULL;
  gt_free((*lci)->tbs.spaceGtUchardbsubstring);
  (*lci)->tbs.spaceGtUchardbsubstring = NULL;
  gt_free (*lci);
  *lci = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x70(%rax), %rdi
callq 0x121e3c
movq (%rbx), %rax
xorl %r15d, %r15d
movq %r15, 0x70(%rax)
movq (%rbx), %rax
movq 0x60(%rax), %rdi
leaq 0x1f3915(%rip), %r14    # 0x3a7f61
movq %r14, %rsi
movl $0x20a, %edx            # imm = 0x20A
callq 0x1045eb
movq (%rbx), %rax
movq %r15, 0x60(%rax)
movq (%rbx), %rdi
movq %r14, %rsi
movl $0x20c, %edx            # imm = 0x20C
callq 0x1045eb
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq