LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_differencecover_compare
static int gt_differencecover_compare (const GtDifferencecover *dcov,
                                       GtLcptrace *lcptrace,
                                       GtUword suffixpos1,
                                       GtUword suffixpos2)
{
  gt_assert(suffixpos1 < dcov->totallength &&
            suffixpos2 < dcov->totallength);
  lcptrace->offset = dc_differencecover_delta(dcov,suffixpos1,suffixpos2);
  lcptrace->idx1 = dc_inversesuftab_get(dcov,suffixpos1 + lcptrace->offset);
  lcptrace->idx2 = dc_inversesuftab_get(dcov,suffixpos2 + lcptrace->offset);
  gt_assert(lcptrace->idx1 != lcptrace->idx2);
  return lcptrace->idx1 < lcptrace->idx2 ? -1 : 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x2c55d8
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jb 0x2c5610
movq 0x3769c1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x250a2a(%rip), %rsi    # 0x516013
leaq 0x2c505f(%rip), %rdx    # 0x58a64f
leaq 0x2c5099(%rip), %rcx    # 0x58a690
leaq 0x2c41bd(%rip), %r8     # 0x5897bb
movl $0x778, %r9d            # imm = 0x778
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c5612
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2c00a0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movl (%rax), %eax
addq %rax, %rsi
callq 0x2c0130
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movl (%rax), %eax
addq %rax, %rsi
callq 0x2c0130
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x2c56c5
movq 0x37690c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x250975(%rip), %rsi    # 0x516013
leaq 0x2c5006(%rip), %rdx    # 0x58a6ab
leaq 0x2c4fe4(%rip), %rcx    # 0x58a690
leaq 0x2c4108(%rip), %r8     # 0x5897bb
movl $0x77c, %r9d            # imm = 0x77C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c56c7
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_new
Enumcodeatposition *gt_Enumcodeatposition_new(const GtEncseq *encseq,
                                              GtReadmode readmode,
                                              unsigned int prefixlength,
                                              unsigned int numofchars)
{
  Enumcodeatposition *ecp;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movl $0x50, %edi
leaq 0x2c4fd7(%rip), %rsi    # 0x58a6e8
movl $0x2e, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x38(%rax)
movl 0x14(%rsp), %edi
movl 0x18(%rsp), %esi
callq 0x25d960
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movl 0x14(%rsp), %edi
movl 0x18(%rsp), %esi
callq 0x25d8b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x3c(%rax)
movb $0x1, %al
cmpl $0x1, 0x1c(%rsp)
movb %al, 0x7(%rsp)
je 0x2c5791
cmpl $0x3, 0x1c(%rsp)
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
movq 0x20(%rsp), %rdi
callq 0xa9d00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x2c57ef
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
jmp 0x2c5809
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x28(%rax)
movq 0x20(%rsp), %rdi
callq 0xaf360
testb $0x1, %al
jne 0x2c5822
jmp 0x2c5847
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0xaf650
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x2c5854
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: newcodelistelem
static bool newcodelistelem(Specialcontext *specialcontext,
                            GtUword smallerval,
                            GtUword largerval,
                            const Enumcodeatposition *ecp)
{
  if (smallerval < largerval)
  {
    GtUword distance = largerval - smallerval;

    if (distance > (GtUword) (ecp->prefixlength-1))
    {
      distance = (GtUword) (ecp->prefixlength-1);
    }
    specialcontext->maxprefixindex = (unsigned int) distance;
    if (ecp->moveforward)
    {
      specialcontext->position = ecp->totallength - smallerval;
    } else
    {
      specialcontext->position = largerval;
    }
    gt_assert(specialcontext->position >=
              (GtUword) specialcontext->maxprefixindex);
    return true;
  }
  return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2c5ae8
movq 0x18(%rsp), %rax
subq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x3c(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0x2c5a50
movq 0x10(%rsp), %rax
movl 0x3c(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x2c5a82
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
subq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2c5a90
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2c5a92
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x2c5adf
movq 0x3764f2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25055b(%rip), %rsi    # 0x516013
leaq 0x2c4cf4(%rip), %rdx    # 0x58a7b3
leaq 0x2c4d32(%rip), %rcx    # 0x58a7f8
leaq 0x2c4c1b(%rip), %r8     # 0x58a6e8
movl $0x5e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c5ae1
movb $0x1, 0x37(%rsp)
jmp 0x2c5aed
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_delete
void gt_Enumcodeatposition_delete(Enumcodeatposition *ecp)
{
  if (ecp != NULL)
  {
    gt_free(ecp->filltable);
    gt_multimappower_delete(ecp->multimappower);
    gt_free(ecp);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c5b47
movq (%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x2c4bcd(%rip), %rsi    # 0x58a6e8
movl $0xa2, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x25db80
movq (%rsp), %rdi
leaq 0x2c4bab(%rip), %rsi    # 0x58a6e8
movl $0xa4, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-enumcodes.c
// Function: gt_Enumcodeatposition_filledqgramcode
GtCodetype gt_Enumcodeatposition_filledqgramcode(const Enumcodeatposition *ecp,
                                                 unsigned int prefixindex,
                                                 GtUword pos)
{
  GtCodetype code;
  unsigned int idx;
  GtUchar cc;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
jbe 0x2c5b77
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x3c(%rcx), %eax
jb 0x2c5baf
movq 0x376422(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25048b(%rip), %rsi    # 0x516013
leaq 0x2c4b73(%rip), %rdx    # 0x58a702
leaq 0x2c4b9f(%rip), %rcx    # 0x58a735
leaq 0x2c4b4b(%rip), %r8     # 0x58a6e8
movl $0xb0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c5bb1
movq 0x20(%rsp), %rax
movq 0x48(%rax), %rax
movl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x2c5cd0
jmp 0x2c5bdf
movq 0x10(%rsp), %rax
movl 0x4(%rsp), %ecx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x2c5c2e
movq 0x3763a3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25040c(%rip), %rsi    # 0x516013
leaq 0x2c4b4d(%rip), %rdx    # 0x58a75b
leaq 0x2c4b20(%rip), %rcx    # 0x58a735
leaq 0x2c4acc(%rip), %r8     # 0x58a6e8
movl $0xb4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c5c30
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x10(%rsp), %rsi
movl 0x4(%rsp), %eax
addq %rax, %rsi
movq 0x20(%rsp), %rax
movl 0x38(%rax), %edx
callq 0xaa7f0
movb %al, 0x3(%rsp)
movzbl 0x3(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2c5c9a
movq 0x376337(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2503a0(%rip), %rsi    # 0x516013
leaq 0x26f2e1(%rip), %rdx    # 0x534f5b
leaq 0x2c4ab4(%rip), %rcx    # 0x58a735
leaq 0x2c4a60(%rip), %r8     # 0x58a6e8
movl $0xb8, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c5c9c
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movzbl 0x3(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2c5bcf
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-lcpvalues.c
// Function: gt_Outlcpinfo_reinit
void gt_Outlcpinfo_reinit(GtOutlcpinfo *outlcpinfo,
                          unsigned int numofchars,
                          unsigned int prefixlength,
                          GtUword numoflcpvalues)
{
  if (outlcpinfo != NULL)
  {
    if (prefixlength > 0)
    {
      outlcpinfo->turnwheel = gt_turningwheel_new(prefixlength,numofchars);
      outlcpinfo->sizeofinfo += gt_turningwheel_size();
    } else
    {
      outlcpinfo->turnwheel = NULL;
    }
    outlcpinfo->sizeofinfo
      += gt_tableoflcpvalues_realloc(&outlcpinfo->lcpsubtab.tableoflcpvalues,
                                     numoflcpvalues);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq %rcx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2c6331
cmpl $0x0, 0x8(%rsp)
jbe 0x2c6303
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
callq 0x2f3460
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
callq 0x2f35c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
jmp 0x2c630f
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
movq (%rsp), %rsi
callq 0x2c6340
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-lcpvalues.c
// Function: gt_tableoflcpvalues_realloc
static size_t gt_tableoflcpvalues_realloc(GtLcpvalues *tableoflcpvalues,
                                          GtUword numoflcpvalues)
{
  if (numoflcpvalues > tableoflcpvalues->numofentries)
  {
    size_t sizeofinfo;

    tableoflcpvalues->bucketoflcpvalues
      = gt_realloc(tableoflcpvalues->bucketoflcpvalues,
                   sizeof (*tableoflcpvalues->bucketoflcpvalues) *
                   numoflcpvalues);
    sizeofinfo = sizeof (*tableoflcpvalues->bucketoflcpvalues) *
                         (numoflcpvalues - tableoflcpvalues->numofentries);
#ifndef NDEBUG
    GT_INITBITTABGENERIC(tableoflcpvalues->isset,
                         tableoflcpvalues->isset,
                         numoflcpvalues);
#endif
    sizeofinfo += GT_NUMOFINTSFORBITS(numoflcpvalues -
                                      tableoflcpvalues->numofentries)
                  * sizeof (GtBitsequence);
    tableoflcpvalues->numoflargelcpvalues = 0;
    tableoflcpvalues->numofentries = numoflcpvalues;
    tableoflcpvalues->lcptaboffset = 0;
    return sizeofinfo;
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2c64af
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rsi
shlq $0x2, %rsi
leaq 0x2c448d(%rip), %rdx    # 0x58a808
movl $0x14b, %ecx            # imm = 0x14B
callq 0xe8540
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq 0x10(%rcx), %rax
shlq $0x2, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
jne 0x2c63c3
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x2c63d9
movq 0x20(%rsp), %rax
subq $0x1, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
shlq $0x3, %rsi
leaq 0x2c440d(%rip), %rdx    # 0x58a808
movl $0x151, %ecx            # imm = 0x151
callq 0xe8540
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x19360
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq 0x10(%rcx), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
jne 0x2c644b
movl $0x1, %eax
movq %rax, (%rsp)
jmp 0x2c6469
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq 0x10(%rcx), %rax
subq $0x1, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
shlq $0x3, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2c64b8
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-lcpvalues.c
// Function: outmany0lcpvalues
static GtUword outmany0lcpvalues(GtUword many,
                                       FILE *outfplcptab)
{
  GtUword i, countout;
#define GT_LCPBUF_NUMBEROFZEROS 1024
  uint8_t outvalues[GT_LCPBUF_NUMBEROFZEROS] = {0};

  countout = many/GT_LCPBUF_NUMBEROFZEROS;
  for (i=0; i<countout; i++)
  {
    gt_xfwrite(outvalues,sizeof (uint8_t),(size_t) GT_LCPBUF_NUMBEROFZEROS,
               outfplcptab);
  }
  gt_xfwrite(outvalues,sizeof (uint8_t),(size_t) many % GT_LCPBUF_NUMBEROFZEROS,
             outfplcptab);
  return many;
}

// Assembly:
subq $0x428, %rsp            # imm = 0x428
movq %rdi, 0x420(%rsp)
movq %rsi, 0x418(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x19360
movq 0x420(%rsp), %rax
shrq $0xa, %rax
movq %rax, 0x408(%rsp)
movq $0x0, 0x410(%rsp)
movq 0x410(%rsp), %rax
cmpq 0x408(%rsp), %rax
jae 0x2c67d8
movq %rsp, %rdi
movq 0x418(%rsp), %rcx
movl $0x1, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x126d30
movq 0x410(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x410(%rsp)
jmp 0x2c6796
movq %rsp, %rdi
movq 0x420(%rsp), %rdx
andq $0x3ff, %rdx            # imm = 0x3FF
movq 0x418(%rsp), %rcx
movl $0x1, %esi
callq 0x126d30
movq 0x420(%rsp), %rax
addq $0x428, %rsp            # imm = 0x428
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-lcpvalues.c
// Function: gt_Outlcpinfo_prebucket
void gt_Outlcpinfo_prebucket(GtOutlcpinfo *outlcpinfo,
                             GtCodetype code,
                             GtUword lcptaboffset)
{
  if (outlcpinfo != NULL)
  {
    if (outlcpinfo->lcpsubtab.lcp2file != NULL ||
        outlcpinfo->lcpsubtab.lcpprocess != NULL)
    {
      outlcpinfo->lcpsubtab.tableoflcpvalues.numoflargelcpvalues = 0;
    } else
    {
      outlcpinfo->lcpsubtab.tableoflcpvalues.lcptaboffset = lcptaboffset;
    }
    if (code > 0)
    {
      (void) gt_turningwheel_next(outlcpinfo->turnwheel);
      if (outlcpinfo->previousbucketwasempty)
      {
        outlcpinfo->minchanged
          = GT_MIN(outlcpinfo->minchanged,
                gt_turningwheel_minchanged(outlcpinfo->turnwheel));
      } else
      {
        outlcpinfo->minchanged
          = gt_turningwheel_minchanged(outlcpinfo->turnwheel);
      }
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2c6cd3
movq 0x20(%rsp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x2c6c27
movq 0x20(%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x2c6c36
movq 0x20(%rsp), %rax
movq $0x0, 0x58(%rax)
jmp 0x2c6c44
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x60(%rax)
cmpq $0x0, 0x18(%rsp)
jbe 0x2c6cd1
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x2f35d0
movq 0x20(%rsp), %rax
testb $0x1, 0x38(%rax)
je 0x2c6cb8
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x2f3680
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0x2c6c99
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x2c6caa
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x2f3680
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
jmp 0x2c6ccf
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x2f3680
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
jmp 0x2c6cd1
jmp 0x2c6cd3
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-lcpvalues.c
// Function: computelocallcpvalue
static GtUword computelocallcpvalue(const Suffixwithcode *previoussuffix,
                                          const Suffixwithcode *currentsuffix,
                                          unsigned int minchanged)
{
  unsigned int lcpvalue;

  if (previoussuffix->code == currentsuffix->code)
  {
    lcpvalue = GT_MIN(previoussuffix->prefixindex,
                   currentsuffix->prefixindex);
  } else
  {
    gt_assert(previoussuffix->code < currentsuffix->code);
    lcpvalue = GT_MIN(previoussuffix->prefixindex,currentsuffix->prefixindex);
    if (minchanged < lcpvalue)
    {
      lcpvalue = minchanged;
    }
  }
  return (GtUword) lcpvalue;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x2c6e5f
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x2c6e46
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0x2c6e52
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x2c6ef7
jmp 0x2c6e61
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x2c6ead
movq 0x375124(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x24f18d(%rip), %rsi    # 0x516013
leaq 0x2c3b7b(%rip), %rdx    # 0x58aa08
leaq 0x2c3b9f(%rip), %rcx    # 0x58aa33
leaq 0x2c396d(%rip), %r8     # 0x58a808
movl $0x67, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c6eaf
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x2c6ecf
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x2c6edb
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jae 0x2c6ef5
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x2c6ef7
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-lcpvalues.c
// Function: outsmalllcpvalues
static void outsmalllcpvalues(Lcpoutput2file *lcp2file,
                              GtUword numoflcps)
{
  gt_assert (lcp2file != NULL);
  lcp2file->countoutputlcpvalues += numoflcps;
  gt_assert(lcp2file->outfplcptab != NULL);
  gt_xfwrite(lcp2file->smalllcpvalues,
             sizeof (*lcp2file->smalllcpvalues),
             (size_t) numoflcps,
             lcp2file->outfplcptab);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2c78be
movq 0x374713(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x24e77c(%rip), %rsi    # 0x516013
leaq 0x2c31ca(%rip), %rdx    # 0x58aa68
leaq 0x2c32ad(%rip), %rcx    # 0x58ab52
leaq 0x2c2f5c(%rip), %r8     # 0x58a808
movl $0x74, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c78c0
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x38(%rax), %rcx
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2c7915
movq 0x3746bc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x24e725(%rip), %rsi    # 0x516013
leaq 0x2c326f(%rip), %rdx    # 0x58ab64
leaq 0x2c3256(%rip), %rcx    # 0x58ab52
leaq 0x2c2f05(%rip), %r8     # 0x58a808
movl $0x76, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c7917
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movl $0x1, %esi
callq 0x126d30
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-linlcp.c
// Function: gt_ENCSEQ_lcp13_kasai
GtUword *gt_ENCSEQ_lcp13_kasai(const GtEncseq *encseq,
                               GtReadmode readmode,
                               GtUword partwidth,
                               GtUword totallength,
                               const ESASuffixptr *suftab,
                               GtCompactUlongStore *inversesuftab)
{
  GtUword pos, lcpvalue = 0, *lcptab;

  lcptab = gt_malloc(sizeof (*lcptab) * partwidth);
  lcptab[0] = 0;
  for (pos=0; pos <= totallength; pos++)
  {
    GtUword fillpos = gt_compact_ulong_store_get(inversesuftab, pos);
    if (fillpos > 0 && fillpos < partwidth)
    {
      GtUword previousstart = ESASUFFIXPTRGET(suftab, fillpos-1);
      while (pos+lcpvalue < totallength &&
             previousstart+lcpvalue < totallength)
      {
        GtUchar cc1, cc2;

        cc1 = gt_encseq_get_encoded_char(encseq, pos+lcpvalue, readmode);
        cc2 = gt_encseq_get_encoded_char(encseq, previousstart+lcpvalue,
                                                readmode);
        if (cc1 == cc2 && GT_ISNOTSPECIAL(cc1))
        {
          lcpvalue++;
        } else
        {
          break;
        }
      }
      lcptab[fillpos] = lcpvalue;
    }
    if (lcpvalue > 0)
    {
      lcpvalue--;
    }
  }
  return lcptab;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x50(%rsp), %rdi
shlq $0x3, %rdi
leaq 0x2c2e98(%rip), %rsi    # 0x58ab82
movl $0x28, %edx
callq 0xe80f0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x48(%rsp), %rax
ja 0x2c7e43
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xa20c0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jbe 0x2c7e18
movq 0x18(%rsp), %rax
cmpq 0x50(%rsp), %rax
jae 0x2c7e18
movq 0x40(%rsp), %rax
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
addq 0x28(%rsp), %rcx
xorl %eax, %eax
cmpq 0x48(%rsp), %rcx
movb %al, 0xd(%rsp)
jae 0x2c7d92
movq 0x10(%rsp), %rax
addq 0x28(%rsp), %rax
cmpq 0x48(%rsp), %rax
setb %al
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
testb $0x1, %al
jne 0x2c7d9c
jmp 0x2c7e05
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq 0x28(%rsp), %rsi
movl 0x5c(%rsp), %edx
callq 0xa9da0
movb %al, 0xf(%rsp)
movq 0x60(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq 0x28(%rsp), %rsi
movl 0x5c(%rsp), %edx
callq 0xa9da0
movb %al, 0xe(%rsp)
movzbl 0xf(%rsp), %eax
movzbl 0xe(%rsp), %ecx
cmpl %ecx, %eax
jne 0x2c7dfe
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jge 0x2c7dfe
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2c7e00
jmp 0x2c7e05
jmp 0x2c7d65
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, 0x28(%rsp)
jbe 0x2c7e2e
movq 0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2c7e30
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2c7d0e
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-linlcp.c
// Function: gt_ENCSEQ_set_relevant_from_inversetab
static void gt_ENCSEQ_set_relevant_from_inversetab(
                                      GtCompactUlongStore *rightposinverse,
                                      const GtEncseq *encseq,
                                      GtReadmode readmode,
                                      const ESASuffixptr *suftab,
                                      GtUword partwidth)
{
  if (gt_encseq_has_specialranges(encseq))
  {
    GtUword idx, pos;

    for (idx = 0; idx < partwidth; idx++)
    {
      pos = ESASUFFIXPTRGET(suftab, idx);
      if (pos > 0)
      {
        GtUchar cc = gt_encseq_get_encoded_char(encseq, pos-1, readmode);
        if (GT_ISSPECIAL(cc))
        {
          gt_compact_ulong_store_update(rightposinverse, pos, idx);
        }
      }
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0xaf360
testb $0x1, %al
jne 0x2c89df
jmp 0x2c8a60
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2c8a5e
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x2c8a4c
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
subq $0x1, %rsi
movl 0x34(%rsp), %edx
callq 0xa9da0
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2c8a4a
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xa21f0
jmp 0x2c8a4c
jmp 0x2c8a4e
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2c89e8
jmp 0x2c8a60
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-linlcp.c
// Function: gt_ENCSEQ_compute_occless_tab
static GtUword *gt_ENCSEQ_compute_occless_tab(const GtEncseq *encseq,
                                              GtReadmode readmode)
{
  GtUword *occless;
  unsigned int charidx, numofchars;

  numofchars = gt_alphabet_num_of_chars(gt_encseq_alphabet(encseq));
  occless = gt_malloc(sizeof (GtUword) * numofchars);
  occless[0] = 0;
  for (charidx = 1U; charidx < numofchars; charidx++)
  {
    GtUword count;

    if (GT_ISDIRCOMPLEMENT(readmode))
    {
      count = gt_encseq_charcount(encseq,
                                  (GtUchar) GT_COMPLEMENTBASE(charidx-1));
    } else
    {
      count = gt_encseq_charcount(encseq, (GtUchar) (charidx-1));
    }
    occless[charidx] = occless[charidx-1] + count;
  }
  return occless;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb0f00
movq %rax, %rdi
callq 0x7e8c0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x2c157e(%rip), %rsi    # 0x58ab82
movl $0xd9, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jae 0x2c96ab
cmpl $0x2, 0x1c(%rsp)
je 0x2c963f
cmpl $0x3, 0x1c(%rsp)
jne 0x2c9660
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl $0x3, %eax
subl %ecx, %eax
movzbl %al, %esi
callq 0xb0f60
movq %rax, (%rsp)
jmp 0x2c9678
movq 0x20(%rsp), %rdi
movl 0xc(%rsp), %eax
subl $0x1, %eax
movzbl %al, %esi
callq 0xb0f60
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
addq (%rsp), %rdx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2c9627
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-lwcheck.c
// Function: gt_check_for_range_occurrence
static GtUword gt_check_for_range_occurrence(const void *suftab,
                                             GT_UNUSED size_t unitsize,
                                             GtUword suffix,
                                             GtUword start,
                                             GtUword end)
{
  GtUword idx;

  for (idx = start; idx <= end; idx++)
  {
    GtUword position = GEN_ESASUFFIXPTRGET(suftab, idx);

    if (suffix == position)
    {
      return idx;
    }
  }
  return ULONG_MAX;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq %r8, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq -0x30(%rsp), %rax
ja 0x2ca352
cmpq $0x4, -0x18(%rsp)
jne 0x2ca30b
movq -0x10(%rsp), %rax
movq -0x38(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, -0x48(%rsp)
jmp 0x2ca31e
movq -0x10(%rsp), %rax
movq -0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rsp)
movq -0x48(%rsp), %rax
movq %rax, -0x40(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x40(%rsp), %rax
jne 0x2ca340
movq -0x38(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x2ca35b
jmp 0x2ca342
movq -0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rsp)
jmp 0x2ca2e3
movq $-0x1, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: gt_kmerstream_delete
static void gt_kmerstream_delete(GtKmerstream *spwp)
{
  if (spwp != NULL) {
    gt_free(spwp->filltable);
    gt_multimappower_delete(spwp->multimappower);
    special_queue_delete(&spwp->specialqueue);
    gt_free(spwp);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2ca600
movq (%rsp), %rax
movq 0x60(%rax), %rdi
leaq 0x2c0b60(%rip), %rsi    # 0x58b12b
movl $0x1a4, %edx            # imm = 0x1A4
callq 0xe88c0
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x25db80
movq (%rsp), %rdi
callq 0x2cb750
movq (%rsp), %rdi
leaq 0x2c0b35(%rip), %rsi    # 0x58b12b
movl $0x1a7, %edx            # imm = 0x1A7
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: gt_kmerstream_new
static GtKmerstream *gt_kmerstream_new(unsigned int numofchars,
                                       unsigned int kmersize)
{
  GtKmerstream *spwp;

  gt_assert(kmersize <= 32);
  spwp = gt_malloc(sizeof (*spwp));
  spwp->multimappower = gt_initmultimappower(numofchars,kmersize);
  gt_kmerstream_init(spwp, numofchars, kmersize);
  special_queue_init(&spwp->specialqueue,kmersize);
  spwp->filltable = gt_filllargestchartable(numofchars,kmersize);
  return spwp;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
cmpl $0x20, 0x10(%rsp)
jbe 0x2cab7b
movq 0x371456(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x24b4bf(%rip), %rsi    # 0x516013
leaq 0x2c077c(%rip), %rdx    # 0x58b2d7
leaq 0x2c0784(%rip), %rcx    # 0x58b2e6
leaq 0x2c05c2(%rip), %r8     # 0x58b12b
movl $0x132, %r9d            # imm = 0x132
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2cab7d
movl $0x80, %edi
leaq 0x2c05a2(%rip), %rsi    # 0x58b12b
movl $0x133, %edx            # imm = 0x133
callq 0xe80f0
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0x25d960
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0x2cb770
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
callq 0x2cb940
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0x25d7b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: gt_kmerstream_newcode
static void gt_kmerstream_newcode(GtKmercode *kmercode,
                                  const GtKmerstream *spwp)
{
  {
    if (special_queue_is_empty(&spwp->specialqueue))
    {
      kmercode->definedspecialposition = false;
      kmercode->specialposition = 0;
      kmercode->code = spwp->codewithoutspecial;
    } else
    {
      GtSpecialcontext *head = special_queue_head_get(&spwp->specialqueue);
      gt_assert(head->lengthofleftcontext < spwp->kmersize);
      kmercode->code = head->codeofleftcontext +
                       spwp->filltable[head->lengthofleftcontext];
      kmercode->definedspecialposition = true;
      kmercode->specialposition = head->lengthofleftcontext;
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2cb810
testb $0x1, %al
jne 0x2cadbe
jmp 0x2cade9
movq 0x10(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x4(%rax)
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2cae7b
movq 0x8(%rsp), %rdi
callq 0x2cb840
movq %rax, (%rsp)
movq (%rsp), %rax
movl (%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x44(%rcx), %eax
jb 0x2cae3f
movq 0x371192(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x24b1fb(%rip), %rsi    # 0x516013
leaq 0x2c04d9(%rip), %rdx    # 0x58b2f8
leaq 0x2c04fd(%rip), %rcx    # 0x58b323
leaq 0x2c02fe(%rip), %r8     # 0x58b12b
movl $0x188, %r9d            # imm = 0x188
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2cae41
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq (%rsp), %rdx
movl (%rdx), %edx
addq (%rax,%rdx,8), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movb $0x1, (%rax)
movq (%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: gt_kmerstream_shiftrightwithchar
static void gt_kmerstream_shiftrightwithchar(GtKmerstream *spwp,
                                             GtUchar charcode)
{
  gt_assert(spwp->windowwidth == spwp->kmersize);
  gt_kmerstream_updatespecialpositions(spwp,charcode,true,
                                       spwp->cyclicwindow[spwp->firstindex]);
  spwp->cyclicwindow[spwp->firstindex] = charcode;
  if (spwp->firstindex < spwp->kmersize-1)
  {
    spwp->firstindex++;
  } else
  {
    spwp->firstindex = 0;
  }
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movl 0x48(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x44(%rcx), %eax
je 0x2caeda
movq 0x3710f7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x24b160(%rip), %rsi    # 0x516013
leaq 0x2c047f(%rip), %rdx    # 0x58b339
leaq 0x2c049c(%rip), %rcx    # 0x58b35d
leaq 0x2c0263(%rip), %r8     # 0x58b12b
movl $0x194, %r9d            # imm = 0x194
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2caedc
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %sil
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x4c(%rcx), %ecx
movl $0x1, %edx
movzbl %sil, %esi
movzbl 0x20(%rax,%rcx), %ecx
callq 0x2ca640
movb 0xf(%rsp), %dl
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0x4c(%rcx), %ecx
movb %dl, 0x20(%rax,%rcx)
movq 0x10(%rsp), %rax
movl 0x4c(%rax), %eax
movq 0x10(%rsp), %rcx
movl 0x44(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x2caf42
movq 0x10(%rsp), %rax
movl 0x4c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4c(%rax)
jmp 0x2caf4e
movq 0x10(%rsp), %rax
movl $0x0, 0x4c(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: gt_kmercodeiterator_encseq_nonspecial_next
const GtKmercode *gt_kmercodeiterator_encseq_nonspecial_next(
                             GtKmercodeiterator *kmercodeiterator)
{
  while (true) {
    if (!kmercodeiterator->hasprocessedfirst) {
      gt_assert(kmercodeiterator->currentposition
                == kmercodeiterator->startpos +
                   kmercodeiterator->spwp->kmersize);
      gt_kmerstream_newcode(&kmercodeiterator->kmercode,
                            kmercodeiterator->spwp);
      kmercodeiterator->hasprocessedfirst = true;
      if (!kmercodeiterator->kmercode.definedspecialposition)
        return &kmercodeiterator->kmercode;
    }
    else {
      if (kmercodeiterator->currentposition < kmercodeiterator->totallength) {
        GtUchar charcode
          = gt_encseq_reader_next_encoded_char(kmercodeiterator->esr);
        gt_kmerstream_shiftrightwithchar(kmercodeiterator->spwp,charcode);
        gt_kmerstream_newcode(&kmercodeiterator->kmercode,
                              kmercodeiterator->spwp);
        kmercodeiterator->currentposition++;
        if (!kmercodeiterator->kmercode.definedspecialposition)
          return &kmercodeiterator->kmercode;
      }
      else
        break;
    }
  }
  return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
jne 0x2cb01d
jmp 0x2caf7a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rsp), %rdx
movq 0x38(%rdx), %rdx
movl 0x44(%rdx), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x2cafd8
movq 0x370ff9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x24b062(%rip), %rsi    # 0x516013
leaq 0x2c01ff(%rip), %rdx    # 0x58b1b7
leaq 0x2c027b(%rip), %rcx    # 0x58b23a
leaq 0x2c0165(%rip), %r8     # 0x58b12b
movl $0x23a, %r9d            # imm = 0x23A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2cafda
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x2cada0
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0x40(%rax)
jne 0x2cb018
movq 0x8(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x10(%rsp)
jmp 0x2cb0ac
jmp 0x2cb09e
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2cb09a
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xaae30
movb %al, 0x7(%rsp)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movzbl 0x7(%rsp), %esi
callq 0x2cae80
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rsi
callq 0x2cada0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0x40(%rax)
jne 0x2cb098
movq 0x8(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x10(%rsp)
jmp 0x2cb0ac
jmp 0x2cb09c
jmp 0x2cb0a3
jmp 0x2cb09e
jmp 0x2caf69
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: gt_kmercodeiterator_delete
void gt_kmercodeiterator_delete(GtKmercodeiterator *kmercodeiterator)
{
  if (kmercodeiterator != NULL)
  {
    gt_encseq_reader_delete(kmercodeiterator->esr);
    gt_kmerstream_delete(kmercodeiterator->spwp);
    gt_sequence_buffer_delete(kmercodeiterator->fb);
    gt_free(kmercodeiterator);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2cb348
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0xac3f0
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x2ca5b0
movq (%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x113bf0
movq (%rsp), %rdi
leaq 0x2bfded(%rip), %rsi    # 0x58b12b
movl $0x2d4, %edx            # imm = 0x2D4
callq 0xe88c0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: gt_kmerstream_init
static void gt_kmerstream_init(GtKmerstream *spwp,
                               unsigned int numofchars,
                               unsigned int kmersize)
{
  spwp->lengthwithoutspecial = 0;
  spwp->codewithoutspecial = 0;
  spwp->kmersize = kmersize;
  spwp->numofchars = numofchars;
  spwp->windowwidth = 0;
  spwp->firstindex = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x50(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x58(%rax)
movl -0x10(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x44(%rax)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x40(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x48(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4c(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: special_queue_reset
static void special_queue_reset(GtSpecialqueue *specialqueue)
{
  specialqueue->noofelements = 0;
  specialqueue->dequeueptr = specialqueue->enqueueptr
                           = specialqueue->queuespace +
                             specialqueue->queuesize - 1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movl 0x18(%rax), %eax
shlq $0x4, %rax
addq %rax, %rcx
addq $-0x10, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: special_queueu_head_delete
static void special_queueu_head_delete(GtSpecialqueue *specialqueue)
{
  specialqueue->noofelements--;
  if (specialqueue->dequeueptr > specialqueue->queuespace)
  {
    specialqueue->dequeueptr--;
  } else
  {
    specialqueue->dequeueptr
      = specialqueue->queuespace + specialqueue->queuesize - 1;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x1c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x2cb889
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x10(%rax)
jmp 0x2cb8ad
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movl 0x18(%rax), %eax
shlq $0x4, %rax
addq %rax, %rcx
addq $-0x10, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: special_queue_enqueue
static void special_queue_enqueue(GtSpecialqueue *specialqueue,
                                  unsigned int lengthofleftcontext,
                                  GtCodetype codeofleftcontext)
{
  specialqueue->noofelements++;
  specialqueue->enqueueptr->codeofleftcontext = codeofleftcontext;
  specialqueue->enqueueptr->lengthofleftcontext = lengthofleftcontext;
  if (specialqueue->enqueueptr > specialqueue->queuespace)
  {
    specialqueue->enqueueptr--;
  } else
  {
    specialqueue->enqueueptr
      = specialqueue->queuespace + specialqueue->queuesize - 1;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x2cb913
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rcx
addq $-0x10, %rcx
movq %rcx, 0x8(%rax)
jmp 0x2cb937
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movl 0x18(%rax), %eax
shlq $0x4, %rax
addq %rax, %rcx
addq $-0x10, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-mappedstr.c
// Function: special_queue_init
static void special_queue_init(GtSpecialqueue *specialqueue,
                               unsigned int queuesize)
{
  specialqueue->queuesize = queuesize;
  specialqueue->queuespace
    = gt_malloc(queuesize * sizeof (*specialqueue->queuespace));
  special_queue_reset(specialqueue);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movl 0xc(%rsp), %eax
movl %eax, %edi
shlq $0x4, %rdi
leaq 0x2bf7c1(%rip), %rsi    # 0x58b12b
movl $0xef, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x2cb7d0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_Sfxmappedrange_map_entire
void *gt_Sfxmappedrange_map_entire(GtSfxmappedrange *sfxmappedrange,
                                   GtError *err)
{
  size_t mappedsize;

  gt_assert(sfxmappedrange != NULL);
  sfxmappedrange->entire = gt_fa_mmap_read(gt_str_get(sfxmappedrange->filename),
                                           &mappedsize,err);
  if (sfxmappedrange->entire == NULL)
  {
    return NULL;
  }
  if (mappedsize != gt_Sfxmappedrange_size_entire(sfxmappedrange))
  {
    gt_error_set(err,
                 "map file %s: mapped size = "GT_WU" != "
                 GT_WU" = expected size",
                 gt_str_get(sfxmappedrange->filename), (GtUword) mappedsize,
                 (GtUword) gt_Sfxmappedrange_size_entire(sfxmappedrange));
    gt_fa_xmunmap(sfxmappedrange->entire);
    sfxmappedrange->entire = NULL;
    return NULL;
  }
  gt_log_log("map %s completely ("GT_WU" units of size %u)",
              gt_str_get(sfxmappedrange->tablename),
              (GtUword) sfxmappedrange->numofunits,
              (unsigned int) sfxmappedrange->sizeofunit);
  return sfxmappedrange->entire;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x2cba3e
movq 0x370593(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x24a5fc(%rip), %rsi    # 0x516013
leaq 0x2bf960(%rip), %rdx    # 0x58b37e
leaq 0x2bf9a7(%rip), %rcx    # 0x58b3cc
leaq 0x2bf987(%rip), %r8     # 0x58b3b3
movl $0x56, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2cba40
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
movq 0x30(%rsp), %r8
leaq 0x28(%rsp), %rsi
leaq 0x2bf951(%rip), %rdx    # 0x58b3b3
movl $0x58, %ecx
callq 0xda4d0
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2cba92
movq $0x0, 0x40(%rsp)
jmp 0x2cbb6b
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2cb990
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
je 0x2cbb2a
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11dee0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2cb990
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %rax, %r8
leaq 0x2bf8ec(%rip), %rsi    # 0x58b3e9
movb $0x0, %al
callq 0xd88c0
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xdb2a0
movq 0x38(%rsp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, 0x40(%rsp)
jmp 0x2cbb6b
movq 0x38(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dee0
movq %rax, %rsi
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rdx
movq 0x38(%rsp), %rax
movq 0x38(%rax), %rax
movl %eax, %ecx
leaq 0x2bf8c9(%rip), %rdi    # 0x58b41f
movb $0x0, %al
callq 0xe7740
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)