LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_checkgreedyunitedist
void gt_checkgreedyunitedist(GT_UNUSED bool forward,
                             const GtUchar *useq,
                             GtUword ulen,
                             const GtUchar *vseq,
                             GtUword vlen)
{
  GtUword edist1, edist2;
  GtFrontResource *frontresource = gt_frontresource_new(10UL);
  bool rightextension = true;
  GtSeqabstract *greedyedistuseq, *greedyedistvseq;

  greedyedistuseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 useq,ulen,0,ulen);
  greedyedistvseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 vseq,vlen,0,vlen);
  edist1 = greedyunitedist(frontresource,greedyedistuseq,greedyedistvseq);
  edist2 = gt_squarededistunit (useq,ulen,vseq,vlen);
#ifdef SKDEBUG
  printf("edist = " GT_WU "\n",edist1);
#endif
  if (edist1 != edist2)
  {
    fprintf(stderr,"greedyunitedist = "GT_WU" != "GT_WU
            " = gt_squarededistunit\n", edist1,edist2);
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_seqabstract_delete(greedyedistuseq);
  gt_seqabstract_delete(greedyedistvseq);
  gt_frontresource_delete(frontresource);
}

// Assembly:
subq $0x58, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl $0xa, %edi
callq 0x253810
movq %rax, 0x18(%rsp)
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x40(%rsp), %r9
xorl %esi, %esi
xorl %edi, %edi
movl %edi, %r8d
andb $0x1, %al
movzbl %al, %edi
callq 0x2b0b50
movq %rax, 0x8(%rsp)
movb 0x17(%rsp), %al
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x30(%rsp), %r9
xorl %esi, %esi
xorl %edi, %edi
movl %edi, %r8d
andb $0x1, %al
movzbl %al, %edi
callq 0x2b0b50
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2538e0
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x4e7a30
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x2f3434
movq 0x348b91(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
leaq 0x29c29f(%rip), %rsi    # 0x58f6c2
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq 0x8(%rsp), %rdi
callq 0x2b0d20
movq (%rsp), %rdi
callq 0x2b0d20
movq 0x18(%rsp), %rdi
callq 0x2538a0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/turnwheels.c
// Function: gt_turningwheel_new
Turningwheel *gt_turningwheel_new(unsigned int numofwheels,
                                  unsigned int asize)
{
  unsigned int i;
  Turningwheel *tw;

  tw = gt_malloc(sizeof (*tw));
  gt_assert(numofwheels < (unsigned int) MAXNUMOFWHEELS);
  gt_assert(numofwheels > 0);
  gt_assert(asize > 0);
  for (i=0; i<numofwheels; i++)
  {
    tw->wheelspace[i] = 0;
  }
  tw->numofwheels = numofwheels;
  tw->asize = asize;
  tw->idx = numofwheels - 1;
  tw->minchanged = 0;
  return tw;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl $0x58, %edi
leaq 0x29c27e(%rip), %rsi    # 0x58f6f6
movl $0x26, %edx
callq 0xe80f0
movq %rax, (%rsp)
cmpl $0x12, 0x14(%rsp)
jb 0x2f34c5
movq 0x348b0c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x222b75(%rip), %rsi    # 0x516013
leaq 0x29c268(%rip), %rdx    # 0x58f70d
leaq 0x29c28d(%rip), %rcx    # 0x58f739
leaq 0x29c243(%rip), %r8     # 0x58f6f6
movl $0x27, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f34c7
jmp 0x2f34c9
cmpl $0x0, 0x14(%rsp)
ja 0x2f3508
movq 0x348ac9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x222b32(%rip), %rsi    # 0x516013
leaq 0x29c265(%rip), %rdx    # 0x58f74d
leaq 0x29c24a(%rip), %rcx    # 0x58f739
leaq 0x29c200(%rip), %r8     # 0x58f6f6
movl $0x28, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f350a
jmp 0x2f350c
cmpl $0x0, 0x10(%rsp)
ja 0x2f354b
movq 0x348a86(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x222aef(%rip), %rsi    # 0x516013
leaq 0x29c232(%rip), %rdx    # 0x58f75d
leaq 0x29c207(%rip), %rcx    # 0x58f739
leaq 0x29c1bd(%rip), %r8     # 0x58f6f6
movl $0x29, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f354d
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jae 0x2f357b
movq (%rsp), %rax
movl 0xc(%rsp), %ecx
movl $0x0, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2f3555
movl 0x14(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x48(%rax)
movl 0x10(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x4c(%rax)
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movq (%rsp), %rax
movl %ecx, 0x50(%rax)
movq (%rsp), %rax
movl $0x0, 0x54(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/turnwheels.c
// Function: gt_turningwheel_next
bool gt_turningwheel_next(Turningwheel *tw)
{
  while (true)
  {
    tw->wheelspace[tw->idx]++;
    tw->minchanged = tw->idx;
    if (tw->wheelspace[tw->idx] == tw->asize)
    {
      tw->wheelspace[tw->idx] = 0;
      if (tw->idx == 0)
      {
        return false;
      }
      tw->idx--;
    } else
    {
      tw->idx = tw->numofwheels-1;
      break;
    }
  }
  return true;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x10(%rsp), %rcx
movl 0x50(%rcx), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rsp), %rax
movl 0x50(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x54(%rax)
movq -0x10(%rsp), %rax
movq -0x10(%rsp), %rcx
movl 0x50(%rcx), %ecx
movl (%rax,%rcx,4), %eax
movq -0x10(%rsp), %rcx
cmpl 0x4c(%rcx), %eax
jne 0x2f364b
movq -0x10(%rsp), %rax
movq -0x10(%rsp), %rcx
movl 0x50(%rcx), %ecx
movl $0x0, (%rax,%rcx,4)
movq -0x10(%rsp), %rax
cmpl $0x0, 0x50(%rax)
jne 0x2f363b
movb $0x0, -0x1(%rsp)
jmp 0x2f366a
movq -0x10(%rsp), %rax
movl 0x50(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x50(%rax)
jmp 0x2f3660
movq -0x10(%rsp), %rax
movl 0x48(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x50(%rax)
jmp 0x2f3665
jmp 0x2f35d5
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/twobits2kmers.c
// Function: scbs_init
static void scbs_init(Singlecharacterbitstreamstate *scbs,
                      const GtTwobitencoding *twobitencoding,
                      unsigned int kmersize)
{
  scbs->tbptr = twobitencoding;
  if (kmersize == 0)
  {
    scbs->currentencoding = 0;
    scbs->shiftright = 0;
  } else
  {
    scbs->currentencoding = *(scbs->tbptr++);
    gt_assert(2U * kmersize < (unsigned int) GT_INTWORDSIZE);
    scbs->shiftright = GT_INTWORDSIZE - GT_MULT2(kmersize);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
cmpl $0x0, 0x4(%rsp)
jne 0x2f3a21
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movl $0x0, (%rax)
jmp 0x2f3a9a
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x4(%rsp), %eax
shll %eax
cmpl $0x40, %eax
jb 0x2f3a84
movq 0x34854d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2225b6(%rip), %rsi    # 0x516013
leaq 0x29bdb8(%rip), %rdx    # 0x58f81c
leaq 0x29bddf(%rip), %rcx    # 0x58f84a
leaq 0x29bd80(%rip), %r8     # 0x58f7f2
movl $0x49, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f3a86
movl 0x4(%rsp), %eax
shll %eax
movl $0x40, %ecx
subl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/twobits2kmers.c
// Function: scbs_next
static inline GtUchar scbs_next(Singlecharacterbitstreamstate *scbs)
{
  if (scbs->shiftright > 0)
  {
    scbs->shiftright -= 2;
  } else
  {
    scbs->currentencoding = *(scbs->tbptr++);
    scbs->shiftright = GT_INTWORDSIZE-2;
  }
  return (GtUchar) (scbs->currentencoding >> scbs->shiftright) & 3;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x2f3b1d
movq -0x8(%rsp), %rax
movl (%rax), %ecx
subl $0x2, %ecx
movl %ecx, (%rax)
jmp 0x2f3b48
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movl $0x3e, (%rax)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rcx
movl (%rcx), %ecx
shrq %cl, %rax
movzbl %al, %eax
andl $0x3, %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/twobits2kmers.c
// Function: mcbs_init
static void mcbs_init(Multicharacterbitstreamstate *mcbs,
                      const GtTwobitencoding *twobitencoding,
                      unsigned int kmersize)
{
  mcbs->tbptr = twobitencoding;
  mcbs->unitoffset = 0;
  mcbs->shiftleft = 2U;
  mcbs->shiftright = (unsigned int) GT_MULT2(GT_UNITSIN2BITENC - kmersize);
  mcbs->maskright = (GtCodetype) (1 << GT_MULT2(kmersize))-1;
  mcbs->currentencoding = *(mcbs->tbptr++);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movl $0x2, 0x14(%rax)
movl $0x20, %ecx
subl -0x14(%rsp), %ecx
shll %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movl -0x14(%rsp), %ecx
shll %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
subq $0x1, %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, (%rcx)
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/twobits2kmers.c
// Function: mcbs_next
static inline GtCodetype mcbs_next(Multicharacterbitstreamstate *mcbs,
                                   unsigned int kmersize)
{
  GtCodetype kmer;

  if (mcbs->unitoffset <= (unsigned int) GT_UNITSIN2BITENC - kmersize)
  {
    kmer = (GtCodetype) (mcbs->currentencoding >> mcbs->shiftright)
                        & mcbs->maskright;
    mcbs->shiftright-=2U;
  } else
  {
    kmer = (GtCodetype)
             ((mcbs->currentencoding << mcbs->shiftleft) |
              (*(mcbs->tbptr) >>
               (GT_MULT2(GT_UNITSIN2BITENC)-mcbs->shiftleft)))
              & mcbs->maskright;
    mcbs->shiftleft+=2;
  }
  if (mcbs->unitoffset < (unsigned int) GT_UNITSIN2BITENC-1)
  {
    mcbs->unitoffset++;
  } else
  {
    mcbs->unitoffset = 0;
    mcbs->shiftleft = 2U;
    mcbs->shiftright = (unsigned int) GT_MULT2(GT_UNITSIN2BITENC - kmersize);
    mcbs->currentencoding = *(mcbs->tbptr++);
  }
  return kmer;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl $0x20, %ecx
subl -0xc(%rsp), %ecx
cmpl %ecx, %eax
ja 0x2f3f70
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
movl 0x18(%rcx), %ecx
shrq %cl, %rax
movq -0x8(%rsp), %rcx
andq 0x20(%rcx), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl 0x18(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0x18(%rax)
jmp 0x2f3fc3
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rsp), %rcx
movl 0x14(%rcx), %ecx
shlq %cl, %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rdx
movq -0x8(%rsp), %rsi
movl $0x40, %ecx
subl 0x14(%rsi), %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq 0x20(%rcx), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl 0x14(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rsp), %rax
cmpl $0x1f, 0x10(%rax)
jae 0x2f3fde
movq -0x8(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x2f4027
movq -0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movl $0x2, 0x14(%rax)
movl $0x20, %ecx
subl -0xc(%rsp), %ecx
shll %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rsp), %rcx
movq (%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, (%rcx)
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/twobits2kmers.c
// Function: showdifferentkmers
static void showdifferentkmers(int line,GtUword pos,GtCodetype kmer1,
                               GtCodetype kmer2)
{
  char buffer[2*GT_INTWORDSIZE+1];

  fprintf(stderr,"line %d: pos="GT_WU"\n",line,pos);
  gt_bitsequence_tostring_units(buffer,(GtBitsequence) kmer1,2U);
  fprintf(stderr,"kmer1=%s\n",buffer);
  gt_bitsequence_tostring_units(buffer,(GtBitsequence) kmer2,2U);
  fprintf(stderr,"kmer2=%s\n",buffer);
  fprintf(stderr,"kmer1="GT_WU" != "GT_WU"= kmer2\n",kmer1,kmer2);
}

// Assembly:
subq $0xa8, %rsp
movl %edi, 0xa4(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq 0x347f43(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movl 0xa4(%rsp), %edx
movq 0x98(%rsp), %rcx
leaq 0x29b833(%rip), %rsi    # 0x58f8a9
movb $0x0, %al
callq 0x199f0
movq %rsp, %rdi
movq 0x90(%rsp), %rsi
movl $0x2, %edx
callq 0x2f41e0
movq 0x347f07(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq %rsp, %rdx
leaq 0x29b815(%rip), %rsi    # 0x58f8bb
movb $0x0, %al
callq 0x199f0
movq %rsp, %rdi
movq 0x88(%rsp), %rsi
movl $0x2, %edx
callq 0x2f41e0
movq 0x347ed7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq %rsp, %rdx
leaq 0x29b7ef(%rip), %rsi    # 0x58f8c5
movb $0x0, %al
callq 0x199f0
movq 0x347ebc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x90(%rsp), %rdx
movq 0x88(%rsp), %rcx
leaq 0x29b7d1(%rip), %rsi    # 0x58f8cf
movb $0x0, %al
callq 0x199f0
addq $0xa8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/twobits2kmers.c
// Function: multireadmode_getencseqkmers_twobitencoding
static void multireadmode_getencseqkmers_twobitencoding(const GtEncseq *encseq,
                                                        unsigned int kmersize)
{
  GtKmercodeiterator *kmercodeiterator;
  int readmode_int;

  for (readmode_int = 0; readmode_int < 4; readmode_int++)
  {
    printf("getencseqkmers_twobitencoding(kmersize=%u,%s)\n",
                         kmersize,
                         gt_readmode_show((GtReadmode) readmode_int));
    kmercodeiterator = gt_kmercodeiterator_encseq_new(encseq,
                                                      (GtReadmode) readmode_int,
                                                      kmersize,0);
    getencseqkmers_twobitencoding(encseq,
                                  (GtReadmode) readmode_int,
                                  kmersize,
                                  kmersize,
                                  false,
                                  gt_checkkmercode,
                                  kmercodeiterator,
                                  NULL,
                                  NULL);
    gt_kmercodeiterator_delete(kmercodeiterator);
    kmercodeiterator = NULL;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl $0x0, 0x1c(%rsp)
cmpl $0x4, 0x1c(%rsp)
jge 0x2f41d2
movl 0x2c(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %edi
callq 0x109990
movl 0x18(%rsp), %esi
movq %rax, %rdx
leaq 0x29b799(%rip), %rdi    # 0x58f8e8
movb $0x0, %al
callq 0x19070
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x2c(%rsp), %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2ca880
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x2c(%rsp), %edx
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %rax
xorl %r8d, %r8d
leaq 0x11f(%rip), %r9        # 0x2f42b0
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x2de9c0
movq 0x20(%rsp), %rdi
callq 0x2cb300
movq $0x0, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2f4125
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/intbits.h
// Function: gt_bitsequence_tostring_units
static inline void gt_bitsequence_tostring_units(char *buffer,
                                                 GtBitsequence bs,
                                                 unsigned int units)
{
  unsigned int idx, unit = 0;
  GtBitsequence mask;

  for (idx=0, unit = 1U, mask = GT_FIRSTBIT;
       mask > 0;
       unit++, mask >>= 1) {
    buffer[idx++] = (bs & mask) ? '1' : '0';
    if (unit % units == 0) {
      buffer[idx++] = ' ';
    }
  }
  buffer[idx] = '\0';
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl $0x0, -0x1c(%rsp)
movl $0x0, -0x18(%rsp)
movl $0x1, -0x1c(%rsp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
jbe 0x2f4294
movq -0x10(%rsp), %rdx
andq -0x28(%rsp), %rdx
movl $0x30, %eax
movl $0x31, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rsp)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x1c(%rsp), %eax
xorl %edx, %edx
divl -0x14(%rsp)
cmpl $0x0, %edx
jne 0x2f4278
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x18(%rsp)
movl %ecx, %ecx
movb $0x20, (%rax,%rcx)
jmp 0x2f427a
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
movq -0x28(%rsp), %rax
shrq %rax
movq %rax, -0x28(%rsp)
jmp 0x2f4215
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movb $0x0, (%rax,%rcx)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/twobits2kmers.c
// Function: gt_checkkmercode
static void gt_checkkmercode(GT_UNUSED void *processinfo,
                             GT_UNUSED bool firstinrange,
                             GT_UNUSED GtUword pos,
                             GT_UNUSED GtCodetype code)
{
#ifndef NDEBUG
  GtKmercodeiterator *kmercodeiterator = (GtKmercodeiterator *) processinfo;
  const GtKmercode *kmercodeptr;

  gt_assert(kmercodeiterator != NULL);
  kmercodeptr = gt_kmercodeiterator_encseq_nonspecial_next(kmercodeiterator);
  gt_assert(kmercodeptr != NULL && !kmercodeptr->definedspecialposition);
  gt_assert(code == kmercodeptr->code);
#endif
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2f4316
movq 0x347cbb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x221d24(%rip), %rsi    # 0x516013
leaq 0x29b59a(%rip), %rdx    # 0x58f890
leaq 0x29b61a(%rip), %rcx    # 0x58f917
leaq 0x29b4ee(%rip), %r8     # 0x58f7f2
movl $0x98, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f4318
movq 0x10(%rsp), %rdi
callq 0x2caf60
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2f4339
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0x2f4371
movq 0x347c60(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x221cc9(%rip), %rsi    # 0x516013
leaq 0x29b5d7(%rip), %rdx    # 0x58f928
leaq 0x29b5bf(%rip), %rcx    # 0x58f917
leaq 0x29b493(%rip), %r8     # 0x58f7f2
movl $0x9a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f4373
jmp 0x2f4375
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0x2f43bd
movq 0x347c14(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x221c7d(%rip), %rsi    # 0x516013
leaq 0x29b5c7(%rip), %rdx    # 0x58f964
leaq 0x29b573(%rip), %rcx    # 0x58f917
leaq 0x29b447(%rip), %r8     # 0x58f7f2
movl $0x9b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f43bf
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mersplit.c
// Function: extractprefixbytecode
static GtUword extractprefixbytecode(GtUword merbytes,
                                           unsigned int prefixlength,
                                           const GtUchar *bytecode)
{
  GtUword idx, code = 0;

  for (idx=0; idx < GT_MIN((GtUword) sizeof (GtUword),merbytes); idx++)
  {
    code = (code << 8) | bytecode[idx];
    if (GT_MULT4(idx+1) == (GtUword) prefixlength)
    {
      break;
    }
    if (GT_MULT4(idx+1) > (GtUword) prefixlength)
    {
      code >>= GT_MULT2(GT_MULT4(idx+1) - prefixlength);
      break;
    }
  }
  return code;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq $0x0, -0x28(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x30(%rsp)
movl $0x8, %eax
cmpq -0x8(%rsp), %rax
jae 0x2f4622
movl $0x8, %eax
movq %rax, -0x38(%rsp)
jmp 0x2f462c
movq -0x8(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rax
movq -0x38(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2f46c7
movq -0x28(%rsp), %rax
shlq $0x8, %rax
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
orq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
shlq $0x2, %rax
movl -0xc(%rsp), %ecx
cmpq %rcx, %rax
jne 0x2f4676
jmp 0x2f46c7
movq -0x20(%rsp), %rax
addq $0x1, %rax
shlq $0x2, %rax
movl -0xc(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x2f46b2
movq -0x20(%rsp), %rcx
addq $0x1, %rcx
shlq $0x2, %rcx
movl -0xc(%rsp), %eax
subq %rax, %rcx
shlq %rcx
movq -0x28(%rsp), %rax
shrq %cl, %rax
movq %rax, -0x28(%rsp)
jmp 0x2f46c7
jmp 0x2f46b4
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x2f4600
movq -0x28(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mersplit.c
// Function: gt_tyrbckinfo_delete
void gt_tyrbckinfo_delete(Tyrbckinfo **tyrbckinfoptr)
{
  Tyrbckinfo *tyrbckinfo = *tyrbckinfoptr;

  gt_fa_xmunmap(tyrbckinfo->mappedmbdfileptr);
  tyrbckinfo->mappedmbdfileptr = NULL;
  gt_free(tyrbckinfo);
  *tyrbckinfoptr = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xdb2a0
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rdi
leaq 0x29a7b9(%rip), %rsi    # 0x58f9a4
movl $0x1c5, %edx            # imm = 0x1C5
callq 0xe88c0
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mersplit.c
// Function: remainingleftmost
static const GtUchar *remainingleftmost(GtUword merbytes,
                                      GtUword byteoffset,
                                      GtUchar remainmask,
                                      GtUchar code,
                                      const GtUchar *leftptr,
                                      const GtUchar *rightptr)
{
  GtUword len, halvemerbytes = GT_MULT2(merbytes);
  GtUchar midcode;
  const GtUchar *midptr;

  gt_assert(halvemerbytes > 0);
  while (leftptr + merbytes < rightptr)
  {
    len = (GtUword) (rightptr-leftptr)/halvemerbytes;
    midptr = leftptr + merbytes * len;
    midcode = extractremainingbytes(remainmask,byteoffset,midptr);
    if (code <= midcode)
    {
      rightptr = midptr;
    } else
    {
      leftptr = midptr;
    }
  }
  return rightptr;
}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb %cl, 0x37(%rsp)
movb %al, 0x36(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x40(%rsp), %rax
shlq %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
ja 0x2f52b1
movq 0x346d20(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x220d89(%rip), %rsi    # 0x516013
leaq 0x29a863(%rip), %rdx    # 0x58faf4
leaq 0x29a86e(%rip), %rcx    # 0x58fb06
leaq 0x29a705(%rip), %r8     # 0x58f9a4
movl $0x5f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f52b3
jmp 0x2f52b5
movq 0x28(%rsp), %rax
addq 0x40(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2f5335
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %rcx
imulq 0x18(%rsp), %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movb 0x37(%rsp), %al
movq 0x38(%rsp), %rsi
movq (%rsp), %rdx
movzbl %al, %edi
callq 0x2f5210
movb %al, 0xf(%rsp)
movzbl 0x36(%rsp), %eax
movzbl 0xf(%rsp), %ecx
cmpl %ecx, %eax
jg 0x2f532a
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2f5333
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x2f52b5
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mersplit.c
// Function: findrightmostmer
static const GtUchar *findrightmostmer(GtUword merbytes,
                                     unsigned int prefixlength,
                                     GtUword code,
                                     const GtUchar *leftptr,
                                     const GtUchar *rightptr)
{
  GtUword len, midcode;
  const GtUchar *midptr;

  while (leftptr + merbytes < rightptr)
  {
    len = (GtUword) (rightptr-leftptr)/GT_MULT2(merbytes);
    midptr = leftptr + merbytes * len;
    midcode = extractprefixbytecode(merbytes,prefixlength,midptr);
    if (midcode > code)
    {
      rightptr = midptr;
    } else
    {
      leftptr = midptr;
    }
  }
  return leftptr;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq 0x40(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2f54e3
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rcx, %rax
movq 0x40(%rsp), %rcx
shlq %rcx
xorl %edx, %edx
divq %rcx
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x40(%rsp), %rcx
imulq 0x18(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movl 0x3c(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x2f45e0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x30(%rsp), %rax
jbe 0x2f54d4
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2f54de
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x2f545c
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: adddistpos2distribution
static int adddistpos2distribution(GtUword countocc,
                                   GtUword position,
                                   void *adddistposinfo,
                                   GT_UNUSED GtError *err)
{
  TyrDfsstate *state = (TyrDfsstate *) adddistposinfo;

  incrementdistribcounts(&state->occdistribution,countocc,1UL);
  if (decideifocc(state,countocc))
  {
    state->occdistribution.spaceCountwithpositions[countocc].positionlist
      = insertListUlong(state->occdistribution.
                               spaceCountwithpositions[countocc].positionlist,
                         position);
  }
  if (state->performtest)
  {
    checknumberofoccurrences(state,countocc,position);
  }
  return 0;
}

// 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 %rax, (%rsp)
movq (%rsp), %rdi
addq $0x38, %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x2f6450
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2f6580
testb $0x1, %al
jne 0x2f5e7c
jmp 0x2f5eb9
movq (%rsp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x2f6620
movq %rax, %rcx
movq (%rsp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
testb $0x1, 0x68(%rax)
je 0x2f5ed6
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2f6670
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: outputsortedstring2index
static int outputsortedstring2index(GtUword countocc,
                                    GtUword position,
                                    void *adddistposinfo,
                                    GtError *err)
{
  TyrDfsstate *state = (TyrDfsstate *) adddistposinfo;

  if (decideifocc(state,countocc))
  {
    if (outputsortedstring2indexviafileptr(state->encseq,
                                           state->mersize,
                                           state->bytebuffer,
                                           state->sizeofbuffer,
                                           state->merindexfpout,
                                           state->countsfilefpout,
                                           position,
                                           countocc,
                                           &state->largecounts,
                                           state->countoutputmers,
                                           err) != 0)
    {
      return -1;
    }
    state->countoutputmers++;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2f6580
testb $0x1, %al
jne 0x2f5f1d
jmp 0x2f5fbc
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x70(%rax), %rdx
movq 0x28(%rsp), %rax
movq 0x78(%rax), %rcx
movq 0x28(%rsp), %rax
movq 0x50(%rax), %r8
movq 0x28(%rsp), %rax
movq 0x58(%rax), %r9
movq 0x40(%rsp), %r14
movq 0x48(%rsp), %rbx
movq 0x28(%rsp), %r11
addq $0x80, %r11
movq 0x28(%rsp), %rax
movq 0x98(%rax), %r10
movq 0x30(%rsp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x2f6790
cmpl $0x0, %eax
je 0x2f5fa5
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f5fc4
movq 0x28(%rsp), %rax
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: tyr_processleafedge
static int tyr_processleafedge(GT_UNUSED bool firstsucc,
                           GtUword fatherdepth,
                           GT_UNUSED Dfsinfo *father,
                           GtUword leafnumber,
                           Dfsstate *astate,
                           GtError *err)
{
  TyrDfsstate *state = (TyrDfsstate*) astate;
  gt_error_check(err);
  if (fatherdepth < state->mersize &&
      leafnumber + state->mersize <= state->totallength &&
      !gt_encseq_contains_special(state->encseq,
                                  state->readmode,
                                  state->esrspace,
                                  leafnumber + fatherdepth,
                                  state->mersize - fatherdepth))
  {
    if (state->processoccurrencecount(1UL,leafnumber,state,err) != 0)
    {
      return -1;
    }
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x33(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2f60bf
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2f6087
jmp 0x2f60bf
movq 0x345f12(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x21ff7b(%rip), %rsi    # 0x516013
leaq 0x220120(%rip), %rdx    # 0x5161bf
leaq 0x299bcb(%rip), %rcx    # 0x58fc71
leaq 0x299a8f(%rip), %r8     # 0x58fb3c
movl $0x1b1, %r9d            # imm = 0x1B1
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f60c1
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2f6149
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
addq (%rcx), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x2f6149
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rsp), %rax
movl 0x28(%rax), %esi
movq (%rsp), %rax
movq 0x60(%rax), %rdx
movq 0x18(%rsp), %rcx
addq 0x28(%rsp), %rcx
movq (%rsp), %rax
movq (%rax), %r8
subq 0x28(%rsp), %r8
callq 0xabb90
testb $0x1, %al
jne 0x2f6149
movq (%rsp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rsp), %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %edi
callq *%rax
cmpl $0x0, %eax
je 0x2f6147
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f6151
jmp 0x2f6149
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: tyr_processcompletenode
static int tyr_processcompletenode(GtUword nodeptrdepth,
                               Dfsinfo *anodeptr,
                               GtUword nodeptrminusonedepth,
                               Dfsstate *astate,
                               GtError *err)
{
  TyrDfsinfo *nodeptr = (TyrDfsinfo*) anodeptr;
  TyrDfsstate *state = (TyrDfsstate*) astate;
  gt_error_check(err);
  if (state->mersize <= nodeptrdepth)
  {
    GtUword fatherdepth;

    fatherdepth = nodeptr->lcptabrightmostleafplus1;
    if (fatherdepth < nodeptrminusonedepth)
    {
      fatherdepth = nodeptrminusonedepth;
    }
    if (fatherdepth < state->mersize)
    {
      if (state->processoccurrencecount((GtUword)
                                        (nodeptr->rightmostleaf -
                                         nodeptr->leftmostleaf + 1),
                                        nodeptr->suftabrightmostleaf,
                                        state,
                                        err) != 0)
      {
        return -1;
      }
    }
  }
  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2f61e1
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2f61a9
jmp 0x2f61e1
movq 0x345df0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x21fe59(%rip), %rsi    # 0x516013
leaq 0x21fffe(%rip), %rdx    # 0x5161bf
leaq 0x299abd(%rip), %rcx    # 0x58fc85
leaq 0x29996d(%rip), %r8     # 0x58fb3c
movl $0x1ca, %r9d            # imm = 0x1CA
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2f61e3
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq 0x38(%rsp), %rax
ja 0x2f6267
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2f6213
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2f6265
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rdi
movq 0x10(%rsp), %rcx
subq (%rcx), %rdi
addq $0x1, %rdi
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq *%rax
cmpl $0x0, %eax
je 0x2f6263
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x2f626f
jmp 0x2f6265
jmp 0x2f6267
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: tyr_assignrightmostleaf
static void tyr_assignrightmostleaf(Dfsinfo *adfsinfo,
                                    GtUword currentindex,
                                    GtUword previoussuffix,
                                    GtUword currentlcp,
                                    GT_UNUSED Dfsstate *dfsstate)
{
  TyrDfsinfo *dfsinfo = (TyrDfsinfo*) adfsinfo;
  dfsinfo->rightmostleaf = currentindex;
  dfsinfo->suftabrightmostleaf = previoussuffix;
  dfsinfo->lcptabrightmostleafplus1 = currentlcp;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x10(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rcx
movq -0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: showfinalstatistics
static void showfinalstatistics(const TyrDfsstate *state,
                                const char *inputindex,
                                GtLogger *logger)
{
  uint64_t dnumofmers = addupdistribution(&state->occdistribution);

  if (state->performtest)
  {
    checknumofmers(state,dnumofmers);
  }
  gt_logger_log(logger,
              "the following output refers to the set of all sequences");
  gt_logger_log(logger,
              "represented by the index \"%s\"",inputindex);
  gt_logger_log(logger,
              "number of "GT_WU"-mers in the sequences not containing a "
              "wildcard: " Formatuint64_t,
              (GtUword) state->mersize,
              PRINTuint64_tcast(dnumofmers));
  gt_logger_log(logger, "show the distribution of the number of occurrences of "
                GT_WU "-mers", (GtUword) state->mersize);
  gt_logger_log(logger,"not containing a wildcard as rows of the form "
              "i d where");
  gt_logger_log(logger, "d is the number of events that a "GT_WU
                "-mer occurs exactly i times", (GtUword) state->mersize);
  showmerdistribution(state);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
addq $0x38, %rdi
callq 0x2f6980
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x68(%rax)
je 0x2f6340
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2f6a00
movq 0x10(%rsp), %rdi
leaq 0x299951(%rip), %rsi    # 0x58fc9d
movb $0x0, %al
callq 0xe7cd0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x299971(%rip), %rsi    # 0x58fcd5
movb $0x0, %al
callq 0xe7cd0
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rcx
leaq 0x29996f(%rip), %rsi    # 0x58fcf3
movb $0x0, %al
callq 0xe7cd0
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
leaq 0x299997(%rip), %rsi    # 0x58fd36
movb $0x0, %al
callq 0xe7cd0
movq 0x10(%rsp), %rdi
leaq 0x2999c3(%rip), %rsi    # 0x58fd75
movb $0x0, %al
callq 0xe7cd0
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
leaq 0x2999e0(%rip), %rsi    # 0x58fdad
movb $0x0, %al
callq 0xe7cd0
movq 0x20(%rsp), %rdi
callq 0x2f6a60
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: outputbytewiseUlongvalue
static void outputbytewiseUlongvalue(FILE *fpout,GtUword value)
{
  size_t i;

  for (i=0; i < sizeof (value); i++)
  {
    (void) putc((int) (value & UCHAR_MAX),fpout);
    value >>= 8;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x8, (%rsp)
jae 0x2f6440
movq 0x8(%rsp), %rax
andq $0xff, %rax
movl %eax, %edi
movq 0x10(%rsp), %rsi
callq 0x19e80
movq 0x8(%rsp), %rax
shrq $0x8, %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2f6406
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: incrementdistribcounts
static void incrementdistribcounts(GtArrayCountwithpositions *occdistribution,
                                   GtUword countocc,GtUword value)
{
  if (countocc >= occdistribution->allocatedCountwithpositions)
  {
    const GtUword addamount = 128UL;
    GtUword idx;

    occdistribution->spaceCountwithpositions
      = gt_realloc(occdistribution->spaceCountwithpositions,
                   sizeof *occdistribution->spaceCountwithpositions
                   * (countocc+addamount));
    for (idx=occdistribution->allocatedCountwithpositions;
         idx<countocc+addamount; idx++)
    {
      occdistribution->spaceCountwithpositions[idx].occcount = 0;
      occdistribution->spaceCountwithpositions[idx].positionlist = NULL;
    }
    occdistribution->allocatedCountwithpositions = countocc+addamount;
  }
  if (countocc + 1 > occdistribution->nextfreeCountwithpositions)
  {
    occdistribution->nextfreeCountwithpositions = countocc+1;
  }
  occdistribution->spaceCountwithpositions[countocc].occcount += value;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x2f652e
movq $0x80, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
addq $0x80, %rsi
shlq $0x4, %rsi
leaq 0x29969d(%rip), %rdx    # 0x58fb3c
movl $0x133, %ecx            # imm = 0x133
callq 0xe8540
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
addq $0x80, %rcx
cmpq %rcx, %rax
jae 0x2f6519
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x2f64c1
movq 0x18(%rsp), %rcx
addq $0x80, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq 0x20(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2f6554
movq 0x18(%rsp), %rcx
addq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
addq (%rax), %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: decideifocc
static bool decideifocc(const TyrDfsstate *state,GtUword countocc)
{
  if (state->minocc > 0)
  {
    if (state->maxocc > 0)
    {
      if (countocc >= state->minocc && countocc <= state->maxocc)
      {
        return true;
      }
    } else
    {
      if (countocc >= state->minocc)
      {
        return true;
      }
    }
  } else
  {
    if (state->maxocc > 0)
    {
      if (countocc <= state->maxocc)
      {
        return true;
      }
    }
  }
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x2f65e6
movq -0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x2f65cb
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2f65c9
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
ja 0x2f65c9
movb $0x1, -0x1(%rsp)
jmp 0x2f6612
jmp 0x2f65e4
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2f65e2
movb $0x1, -0x1(%rsp)
jmp 0x2f6612
jmp 0x2f65e4
jmp 0x2f660d
movq -0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x2f660b
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
ja 0x2f6609
movb $0x1, -0x1(%rsp)
jmp 0x2f6612
jmp 0x2f660b
jmp 0x2f660d
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: insertListUlong
static /*@null@*/ ListUlong *insertListUlong(ListUlong *liststart,
                                             GtUword position)
{
  ListUlong *newnode;

  newnode = gt_malloc(sizeof *newnode);
  newnode->position = position;
  newnode->nextptr = liststart;
  return newnode;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x10, %edi
leaq 0x299502(%rip), %rsi    # 0x58fb3c
movl $0x9d, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: checknumberofoccurrences
static void checknumberofoccurrences(const TyrDfsstate *dfsstate,
                                     GtUword countocc,
                                     GtUword position)
{
  GtMMsearchiterator *mmsi;
  GtUword idx, bfcount;

  for (idx = 0; idx < dfsstate->mersize; idx++)
  {
    dfsstate->currentmer[idx] =
              gt_encseq_get_encoded_char(dfsstate->encseq,position+idx,
                                                dfsstate->readmode);
  }
  mmsi = gt_mmsearchiterator_new_complete_plain(dfsstate->encseq,
                                              dfsstate->suftab,
                                              0,
                                              dfsstate->totallength,
                                              0,
                                              dfsstate->readmode,
                                              dfsstate->currentmer,
                                              dfsstate->mersize);
  bfcount = gt_mmsearchiterator_count(mmsi);
  if (bfcount != countocc)
  {
    fprintf(stderr,"bfcount = "GT_WU" != "GT_WU" = countocc\n",
            bfcount,countocc);
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_mmsearchiterator_delete(mmsi);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2f66e1
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x30(%rsp), %rsi
addq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rax
movl 0x28(%rax), %edx
callq 0xa9da0
movb %al, %dl
movq 0x40(%rsp), %rax
movq 0xa8(%rax), %rax
movq 0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2f668c
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x40(%rsp), %rax
movq 0xa0(%rax), %rsi
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x40(%rsp), %rax
movl 0x28(%rax), %r9d
movq 0x40(%rsp), %rax
movq 0xa8(%rax), %r10
movq 0x40(%rsp), %rax
movq (%rax), %rax
xorl %edx, %edx
movl %edx, %r8d
movq %r8, %rdx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x238170
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2382c0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x2f677e
movq 0x345847(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0x299499(%rip), %rsi    # 0x58fc06
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq 0x28(%rsp), %rdi
callq 0x2384d0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: addupdistribution
static uint64_t addupdistribution(const GtArrayCountwithpositions *distribution)
{
  GtUword idx;
  uint64_t addcount = 0;

  for (idx=0; idx < distribution->nextfreeCountwithpositions; idx++)
  {
    if (distribution->spaceCountwithpositions[idx].occcount > 0)
    {
      addcount += (uint64_t)
                  (idx * distribution->spaceCountwithpositions[idx].occcount);
    }
  }
  return addcount;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x18(%rsp)
movq $0x0, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2f69fa
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jbe 0x2f69e8
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
movq -0x10(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
imulq (%rcx), %rax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
jmp 0x2f69ea
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x2f6997
movq -0x18(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: checknumofmers
static void checknumofmers(const TyrDfsstate *state,
                           uint64_t dnumofmers)
{
  uint64_t bfnumofmers = bruteforcecountnumofmers(state);

  if (dnumofmers != bfnumofmers)
  {
    fprintf(stderr,"numofmers(distribution) = " Formatuint64_t " != "
                   Formatuint64_t,
                   PRINTuint64_tcast(dnumofmers),
                   PRINTuint64_tcast(bfnumofmers));
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2f6b50
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
je 0x2f6a52
movq 0x345572(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x2993ac(%rip), %rsi    # 0x58fded
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
addq $0x18, %rsp
retq
nopw (%rax,%rax)