LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_suf_lcp_iterator_next
GtUword gt_sain_suf_lcp_iterator_next(GtUword *lcpvalue,
                                      GtSainSufLcpIterator *suflcpiterator)
{
  GtUsainindextype previoussuffix, currentsuffix;
  gt_assert(suflcpiterator != NULL);

  previoussuffix = suflcpiterator->suftab[suflcpiterator->currentsuftabindex++];
  currentsuffix = suflcpiterator->suftab[suflcpiterator->currentsuftabindex];
  *lcpvalue = (GtUword) suflcpiterator->plcptab[currentsuffix];
  return (GtUword) previoussuffix;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2d1f4e
movq 0x36a083(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2440ec(%rip), %rsi    # 0x516013
leaq 0x2a4e2b(%rip), %rdx    # 0x576d59
leaq 0x2ba20d(%rip), %rcx    # 0x58c142
leaq 0x2ba12c(%rip), %r8     # 0x58c068
movl $0x70a, %r9d            # imm = 0x70A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d1f50
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rdx
movq 0x20(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x20(%rdx)
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, (%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_allocate_tmpspace
static void gt_sain_allocate_tmpspace(GtSainseq *sainseq,
                                      GtUword maxvalue,
                                      GtUword len)
{
  sainseq->bucketsize
    = (GtUsainindextype *)
      gt_calloc((size_t) sainseq->numofchars,sizeof (*sainseq->bucketsize));
  sainseq->bucketfillptr
    = (GtUsainindextype *)
      gt_malloc(sizeof (*sainseq->bucketfillptr) * sainseq->numofchars);
  if (gt_sain_decideforfastmethod(maxvalue,len,sainseq->numofchars))
  {
    sainseq->roundtable = (GtUsainindextype *)
                          gt_malloc(sizeof (*sainseq->roundtable) *
                                    (size_t) GT_MULT2(sainseq->numofchars));
  } else
  {
    sainseq->roundtable = NULL;
  }
  sainseq->sstarfirstcharcount
    = (GtUsainindextype *)
      gt_calloc((size_t) sainseq->numofchars,
                sizeof (*sainseq->sstarfirstcharcount));
  sainseq->bucketfillptrpoints2suftab = false;
  sainseq->bucketsizepoints2suftab = false;
  sainseq->roundtablepoints2suftab = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x4, %esi
leaq 0x2ba091(%rip), %rdx    # 0x58c068
movl $0x5a, %ecx
callq 0xe83c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
shlq $0x2, %rdi
leaq 0x2ba067(%rip), %rsi    # 0x58c068
movl $0x5d, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x2d20c0
testb $0x1, %al
jne 0x2d2034
jmp 0x2d2063
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
shlq %rdi
shlq $0x2, %rdi
leaq 0x2ba01d(%rip), %rsi    # 0x58c068
movl $0x62, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x2d2070
movq 0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x4, %esi
leaq 0x2b9fe3(%rip), %rdx    # 0x58c068
movl $0x6a, %ecx
callq 0xe83c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x54(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x55(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x56(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_insertSstarsuffixes
static GtUword gt_sain_insertSstarsuffixes(GtSainseq *sainseq,
                                           GtUsainindextype *suftab,
                                           GtLogger *logger)
{
  switch (sainseq->seqtype)
  {
    case GT_SAIN_PLAINSEQ:
      return gt_sain_PLAINSEQ_insertSstarsuffixes(sainseq,
                                                  sainseq->seq.plainseq,
                                                  suftab,logger);
    case GT_SAIN_ENCSEQ:
      return gt_sain_ENCSEQ_insertSstarsuffixes(sainseq,
                                                sainseq->seq.encseq,
                                                suftab,logger);
    case GT_SAIN_INTSEQ:
      return gt_sain_INTSEQ_insertSstarsuffixes(sainseq,
                                                sainseq->seq.array,
                                                suftab,logger);
    case GT_SAIN_BARE_ENCSEQ:
      return gt_sain_BARE_ENCSEQ_insertSstarsuffixes(sainseq,
                                                     sainseq->seq.plainseq,
                                                     suftab,logger);
  }
  /*@ignore@*/
  return 0;
  /*@end@*/
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x50(%rax), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x2d21fd
movq (%rsp), %rax
leaq 0x2b9e74(%rip), %rcx    # 0x58bfd8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x2d4280
movq %rax, 0x20(%rsp)
jmp 0x2d2206
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x2d4480
movq %rax, 0x20(%rsp)
jmp 0x2d2206
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x2d4740
movq %rax, 0x20(%rsp)
jmp 0x2d2206
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x2d4930
movq %rax, 0x20(%rsp)
jmp 0x2d2206
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_incrementfirstSstar
static void gt_sain_incrementfirstSstar(GtSainseq *sainseq,
                                        GtUsainindextype *suftab)
{
  GtUword charidx;
  GtUsainindextype sum = 0;

  for (charidx = 0; charidx < sainseq->numofchars; charidx++)
  {
    sum += sainseq->bucketsize[charidx];
    gt_assert(sainseq->bucketfillptr[charidx] <= sum);
    if (sainseq->bucketfillptr[charidx] < sum)
    {
      suftab[sainseq->bucketfillptr[charidx]] += sainseq->totallength;
    }
    sainseq->roundtable[charidx] = 0;
    sainseq->roundtable[charidx+sainseq->numofchars] = 0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2d2331
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0xc(%rsp), %eax
jbe 0x2d22ab
movq 0x369d26(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x243d8f(%rip), %rsi    # 0x516013
leaq 0x2ba24c(%rip), %rdx    # 0x58c4d7
leaq 0x2ba26c(%rip), %rcx    # 0x58c4fe
leaq 0x2b9dcf(%rip), %r8     # 0x58c068
movl $0x2c2, %r9d            # imm = 0x2C2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d22ad
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0xc(%rsp), %eax
jae 0x2d22eb
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x10(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl (%rax,%rcx,4), %edx
addq %rsi, %rdx
movl %edx, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rdx
addq 0x8(%rdx), %rcx
movl $0x0, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2d222f
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_startbuckets
static void gt_sain_startbuckets(GtSainseq *sainseq)
{
  GtUword charidx;
  GtUsainindextype previous;

  previous = sainseq->bucketfillptr[0] = 0;
  for (charidx = 1UL; charidx < sainseq->numofchars; charidx++)
  {
    previous += sainseq->bucketsize[charidx-1];
    sainseq->bucketfillptr[charidx] = previous;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movl $0x0, (%rax)
movl $0x0, -0x14(%rsp)
movq $0x1, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2d23b7
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %edx
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x2d2365
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_induceLtypesuffixes1
static void gt_sain_induceLtypesuffixes1(GtSainseq *sainseq,
                                         GtSsainindextype *suftab,
                                         GtUword nonspecialentries)
{
  switch (sainseq->seqtype)
  {
    case GT_SAIN_PLAINSEQ:
    case GT_SAIN_BARE_ENCSEQ:
      (sainseq->roundtable == NULL
        ? gt_sain_PLAINSEQ_induceLtypesuffixes1
        : gt_sain_PLAINSEQ_fast_induceLtypesuffixes1)
           (sainseq,sainseq->seq.plainseq,suftab,nonspecialentries);
      break;
    case GT_SAIN_ENCSEQ:
      (sainseq->roundtable == NULL
        ? gt_sain_ENCSEQ_induceLtypesuffixes1
        : gt_sain_ENCSEQ_fast_induceLtypesuffixes1)
           (sainseq,sainseq->seq.encseq,suftab,nonspecialentries);
      break;
    case GT_SAIN_INTSEQ:
      (sainseq->roundtable == NULL
        ? gt_sain_INTSEQ_induceLtypesuffixes1
        : gt_sain_INTSEQ_fast_induceLtypesuffixes1)
           (sainseq,sainseq->seq.array,suftab,nonspecialentries);
      break;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x50(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x2d24ae
movq 0x8(%rsp), %rax
leaq 0x2b9bf2(%rip), %rcx    # 0x58bfe8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdx
leaq 0x2eb1(%rip), %rax      # 0x2d52c0
leaq 0x2c4a(%rip), %rcx      # 0x2d5060
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x38(%rcx), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *%rax
jmp 0x2d24ae
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdx
leaq 0x3446(%rip), %rax      # 0x2d5890
leaq 0x31cf(%rip), %rcx      # 0x2d5620
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x38(%rcx), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *%rax
jmp 0x2d24ae
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdx
leaq 0x39db(%rip), %rax      # 0x2d5e60
leaq 0x3784(%rip), %rcx      # 0x2d5c10
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x38(%rcx), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *%rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_adjustsuftab
static void gt_sain_adjustsuftab(GtUword totallength,GtSsainindextype *suftab,
                                 GtUword nonspecialentries)
{
  GtSsainindextype *suftabptr;

  for (suftabptr = suftab + nonspecialentries - 1; suftabptr >= suftab;
       suftabptr--)
  {
    if (*suftabptr > 0 && *suftabptr < (GtSsainindextype) totallength)
    {
      GtSsainindextype *nextgteq;

      *suftabptr += (GtSsainindextype) totallength;
      nextgteq = suftabptr - 1;
      while (nextgteq >= suftab && *nextgteq < (GtSsainindextype) totallength)
      {
        nextgteq--;
      }
      if (*nextgteq >= (GtSsainindextype) totallength)
      {
        *nextgteq -= (GtSsainindextype) totallength;
      }
      suftabptr = nextgteq;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
addq $-0x4, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x10(%rsp), %rax
jb 0x2d25bb
movq -0x20(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x2d25a6
movq -0x20(%rsp), %rax
movl (%rax), %eax
movq -0x8(%rsp), %rcx
cmpl %ecx, %eax
jge 0x2d25a6
movq -0x8(%rsp), %rax
movl %eax, %ecx
movq -0x20(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x20(%rsp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rcx
xorl %eax, %eax
cmpq -0x10(%rsp), %rcx
movb %al, -0x29(%rsp)
jb 0x2d2560
movq -0x28(%rsp), %rax
movl (%rax), %eax
movq -0x8(%rsp), %rcx
cmpl %ecx, %eax
setl %al
movb %al, -0x29(%rsp)
movb -0x29(%rsp), %al
testb $0x1, %al
jne 0x2d256a
jmp 0x2d257a
movq -0x28(%rsp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rsp)
jmp 0x2d2539
movq -0x28(%rsp), %rax
movl (%rax), %eax
movq -0x8(%rsp), %rcx
cmpl %ecx, %eax
jl 0x2d259c
movq -0x8(%rsp), %rax
movl %eax, %edx
movq -0x28(%rsp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
jmp 0x2d25a8
movq -0x20(%rsp), %rax
addq $-0x4, %rax
movq %rax, -0x20(%rsp)
jmp 0x2d24e9
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_endbuckets
static void gt_sain_endbuckets(GtSainseq *sainseq)
{
  GtUword charidx;
  GtUsainindextype previous;

  previous = sainseq->bucketfillptr[0] = sainseq->bucketsize[0];
  for (charidx = 1UL; charidx < sainseq->numofchars; charidx++)
  {
    previous += sainseq->bucketsize[charidx];
    sainseq->bucketfillptr[charidx] = previous;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl (%rax), %eax
movq -0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movl %eax, (%rcx)
movl %eax, -0x14(%rsp)
movq $0x1, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2d2636
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %edx
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x2d25e8
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_induceStypesuffixes1
static void gt_sain_induceStypesuffixes1(GtSainseq *sainseq,
                                         GtSsainindextype *suftab,
                                         GtUword nonspecialentries)
{
  switch (sainseq->seqtype)
  {
    case GT_SAIN_PLAINSEQ:
    case GT_SAIN_BARE_ENCSEQ:
      (sainseq->roundtable == NULL
        ? gt_sain_PLAINSEQ_induceStypesuffixes1
        : gt_sain_PLAINSEQ_fast_induceStypesuffixes1)
           (sainseq,sainseq->seq.plainseq,suftab,nonspecialentries);
      break;
    case GT_SAIN_ENCSEQ:
      (sainseq->roundtable == NULL
        ? gt_sain_ENCSEQ_induceStypesuffixes1
        : gt_sain_ENCSEQ_fast_induceStypesuffixes1)
           (sainseq,sainseq->seq.encseq,suftab,nonspecialentries);
      break;
    case GT_SAIN_INTSEQ:
      (sainseq->roundtable == NULL
        ? gt_sain_INTSEQ_induceStypesuffixes1
        : gt_sain_INTSEQ_fast_induceStypesuffixes1)
           (sainseq,sainseq->seq.array,suftab,nonspecialentries);
      break;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x50(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x2d272e
movq 0x8(%rsp), %rax
leaq 0x2b9982(%rip), %rcx    # 0x58bff8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdx
leaq 0x3db1(%rip), %rax      # 0x2d6440
leaq 0x3b2a(%rip), %rcx      # 0x2d61c0
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x38(%rcx), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *%rax
jmp 0x2d272e
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdx
leaq 0x4386(%rip), %rax      # 0x2d6a50
leaq 0x40ef(%rip), %rcx      # 0x2d67c0
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x38(%rcx), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *%rax
jmp 0x2d272e
movq 0x20(%rsp), %rax
movq 0x30(%rax), %rdx
leaq 0x495b(%rip), %rax      # 0x2d7060
leaq 0x46d4(%rip), %rcx      # 0x2d6de0
cmpq $0x0, %rdx
cmoveq %rcx, %rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x38(%rcx), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq *%rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_assignSstarlength
static void gt_sain_assignSstarlength(GtSainseq *sainseq,
                                      GtUsainindextype *lentab)
{
  switch (sainseq->seqtype)
  {
    case GT_SAIN_PLAINSEQ:
      gt_sain_PLAINSEQ_assignSstarlength(sainseq,sainseq->seq.plainseq,lentab);
      break;
    case GT_SAIN_ENCSEQ:
      gt_sain_ENCSEQ_assignSstarlength(sainseq,sainseq->seq.encseq,lentab);
      break;
    case GT_SAIN_INTSEQ:
      gt_sain_INTSEQ_assignSstarlength(sainseq,sainseq->seq.array,lentab);
      break;
    case GT_SAIN_BARE_ENCSEQ:
      gt_sain_BARE_ENCSEQ_assignSstarlength(sainseq,sainseq->seq.plainseq,
                                            lentab);
      break;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x50(%rax), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x2d2a2a
movq (%rsp), %rax
leaq 0x2b964d(%rip), %rcx    # 0x58c008
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x2d79a0
jmp 0x2d2a2a
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x2d7b00
jmp 0x2d2a2a
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x2d7cf0
jmp 0x2d2a2a
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x2d7e50
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_setundefined
static void gt_sain_setundefined(bool fwd,GtUsainindextype *suftab,
                                 GtUword start, GtUword end)
{
  GtUsainindextype *ptr;

  if (fwd)
  {
    for (ptr = suftab + start; ptr <= suftab + end; ptr++)
    {
      *ptr = 0;
    }
  } else
  {
    for (ptr = suftab + end; ptr >= suftab + start; ptr--)
    {
      *ptr = 0;
    }
  }
}

// Assembly:
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
testb $0x1, -0x1(%rsp)
je 0x2d311d
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
movq -0x20(%rsp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
ja 0x2d311b
movq -0x28(%rsp), %rax
movl $0x0, (%rax)
movq -0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rsp)
jmp 0x2d30e5
jmp 0x2d316b
movq -0x10(%rsp), %rax
movq -0x20(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x2d3169
movq -0x28(%rsp), %rax
movl $0x0, (%rax)
movq -0x28(%rsp), %rax
addq $-0x4, %rax
movq %rax, -0x28(%rsp)
jmp 0x2d3133
jmp 0x2d316b
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_movenames2front
static void gt_sain_movenames2front(GtUsainindextype *suftab,
                                    GtUword numberofsuffixes,
                                    GtUword totallength)
{
  GtUsainindextype *rptr, *wptr;
  const GtUsainindextype *maxrptr;

  gt_assert(totallength > 0);
  maxrptr = suftab + numberofsuffixes + GT_DIV2(totallength-1);
  for (rptr = wptr = suftab + numberofsuffixes; rptr <= maxrptr; rptr++)
  {
    if (*rptr > 0)
    {
      *(wptr++) = *rptr - 1UL; /* As we have used names with
                                  offset 1 to distinguish them
                                  from the undefined values
                                  signified by 0 */
    }
  }
  gt_assert(wptr == suftab + GT_MULT2(numberofsuffixes));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
ja 0x2d31c3
movq 0x368e0e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x242e77(%rip), %rsi    # 0x516013
leaq 0x2b996a(%rip), %rdx    # 0x58cb0d
leaq 0x2b9973(%rip), %rcx    # 0x58cb1d
leaq 0x2b8eb7(%rip), %r8     # 0x58c068
movl $0x40f, %r9d            # imm = 0x40F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d31c5
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
shrq %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
ja 0x2d3251
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
jbe 0x2d323f
movq 0x18(%rsp), %rax
movl (%rax), %eax
subq $0x1, %rax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, 0x10(%rsp)
movl %ecx, (%rax)
jmp 0x2d3241
movq 0x18(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x18(%rsp)
jmp 0x2d3209
jmp 0x2d3253
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %rdx
shlq %rdx
shlq $0x2, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x2d32a9
movq 0x368d28(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x242d91(%rip), %rsi    # 0x516013
leaq 0x2b98ac(%rip), %rdx    # 0x58cb35
leaq 0x2b988d(%rip), %rcx    # 0x58cb1d
leaq 0x2b8dd1(%rip), %r8     # 0x58c068
movl $0x41b, %r9d            # imm = 0x41B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d32ab
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_expandorder2original
static void gt_sain_expandorder2original(GtSainseq *sainseq,
                                         GtUword numberofsuffixes,
                                         GtUsainindextype *suftab)
{
  switch (sainseq->seqtype)
  {
    case GT_SAIN_PLAINSEQ:
      gt_sain_PLAINSEQ_expandorder2original(sainseq,sainseq->seq.plainseq,
                                            numberofsuffixes,suftab);
      break;
    case GT_SAIN_ENCSEQ:
      gt_sain_ENCSEQ_expandorder2original(sainseq,sainseq->seq.encseq,
                                          numberofsuffixes,suftab);
      break;
    case GT_SAIN_INTSEQ:
      gt_sain_INTSEQ_expandorder2original(sainseq,sainseq->seq.array,
                                          numberofsuffixes,suftab);
      break;
    case GT_SAIN_BARE_ENCSEQ:
      gt_sain_BARE_ENCSEQ_expandorder2original(sainseq,sainseq->seq.plainseq,
                                               numberofsuffixes,suftab);
      break;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x50(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x2d36c9
movq 0x8(%rsp), %rax
leaq 0x2b89e2(%rip), %rcx    # 0x58c028
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d8830
jmp 0x2d36c9
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d8a70
jmp 0x2d36c9
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d8da0
jmp 0x2d36c9
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d9050
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_determineSstarfirstchardist
static void gt_sain_determineSstarfirstchardist(GtSainseq *sainseq)
{
  const GtUsainindextype *seqptr;
  GtUword nextcc = GT_UNIQUEINT(sainseq->totallength);
  bool nextisStype = true;

  gt_assert(sainseq->seqtype == GT_SAIN_INTSEQ);
  for (seqptr = sainseq->seq.array + sainseq->totallength - 1;
       seqptr >= sainseq->seq.array; seqptr--)
  {
    GtUword currentcc = (GtUword) *seqptr;
    bool currentisStype = (currentcc < nextcc ||
                           (currentcc == nextcc && nextisStype)) ? true : false;
    if (!currentisStype && nextisStype)
    {
      sainseq->sstarfirstcharcount[nextcc]++;
    }
    sainseq->bucketsize[currentcc]++;
    nextisStype = currentisStype;
    nextcc = currentcc;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x20(%rsp)
movb $0x1, 0x1f(%rsp)
movq 0x30(%rsp), %rax
cmpl $0x1, 0x50(%rax)
je 0x2d3734
movq 0x36889d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x242906(%rip), %rsi    # 0x516013
leaq 0x2b9573(%rip), %rdx    # 0x58cc87
leaq 0x2b958f(%rip), %rcx    # 0x58ccaa
leaq 0x2b8946(%rip), %r8     # 0x58c068
movl $0x4b1, %r9d            # imm = 0x4B1
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d3736
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
addq $-0x4, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jb 0x2d382b
movq 0x28(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movb $0x1, %al
cmpq 0x20(%rsp), %rcx
movb %al, 0xe(%rsp)
jb 0x2d37ab
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rsp), %rcx
movb %al, 0xd(%rsp)
jne 0x2d37a3
movb 0x1f(%rsp), %al
movb %al, 0xd(%rsp)
movb 0xd(%rsp), %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
jne 0x2d37ed
testb $0x1, 0x1f(%rsp)
je 0x2d37ed
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $-0x4, %rax
movq %rax, 0x28(%rsp)
jmp 0x2d3757
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_checkorder
static void gt_sain_checkorder(const GtSainseq *sainseq,
                               const GtUsainindextype *suftab,
                               GtUword start,
                               GtUword end)
{
  GtUword idx;

  for (idx = start+1; idx <= end; idx++)
  {
    int cmp = gt_sain_compare_suffixes(sainseq,(GtUword) suftab[idx-1],
                                       (GtUword) suftab[idx]);

    if (cmp != -1)
    {
      fprintf(stderr,
              "%s: check interval ["GT_WU","GT_WU"] at idx="GT_WU": suffix "
              ""GT_WU" >= "GT_WU"\n",__func__,start,end,idx,
              (GtUword) suftab[idx-1],
              (GtUword) suftab[idx]);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x28(%rsp), %rax
ja 0x2d3914
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %esi
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %edx
callq 0x2d92f0
movl %eax, 0x1c(%rsp)
cmpl $-0x1, 0x1c(%rsp)
je 0x2d38ff
movq 0x3686fc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x20(%rsp), %r9
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rdx
subq $0x1, %rdx
movl (%rax,%rdx,4), %eax
movl %eax, %r10d
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rdx
movl (%rax,%rdx,4), %eax
leaq 0x2b93f0(%rip), %rsi    # 0x58ccce
leaq 0x2b9425(%rip), %rdx    # 0x58cd0a
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
jmp 0x2d3901
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2d3856
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_induceLtypesuffixes2
static void gt_sain_induceLtypesuffixes2(const GtSainseq *sainseq,
                                         GtSsainindextype *suftab,
                                         GtUword nonspecialentries)
{
  switch (sainseq->seqtype)
  {
    case GT_SAIN_PLAINSEQ:
    case GT_SAIN_BARE_ENCSEQ:
      gt_sain_PLAINSEQ_induceLtypesuffixes2(sainseq,sainseq->seq.plainseq,
                                            suftab,nonspecialentries);
      break;
    case GT_SAIN_ENCSEQ:
      gt_sain_ENCSEQ_induceLtypesuffixes2(sainseq,sainseq->seq.encseq,suftab,
                                          nonspecialentries);
      break;
    case GT_SAIN_INTSEQ:
      gt_sain_INTSEQ_induceLtypesuffixes2(sainseq,sainseq->seq.array,
                                          suftab,nonspecialentries);
      break;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x50(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x2d3c56
movq 0x8(%rsp), %rax
leaq 0x2b8446(%rip), %rcx    # 0x58c038
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d94b0
jmp 0x2d3c56
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d96e0
jmp 0x2d3c56
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d9930
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_induceStypesuffixes2
static void gt_sain_induceStypesuffixes2(const GtSainseq *sainseq,
                                         GtSsainindextype *suftab,
                                         GtUword nonspecialentries)
{
  switch (sainseq->seqtype)
  {
    case GT_SAIN_PLAINSEQ:
    case GT_SAIN_BARE_ENCSEQ:
      gt_sain_PLAINSEQ_induceStypesuffixes2(sainseq,sainseq->seq.plainseq,
                                            suftab,nonspecialentries);
      break;
    case GT_SAIN_ENCSEQ:
      gt_sain_ENCSEQ_induceStypesuffixes2(sainseq,sainseq->seq.encseq,suftab,
                                          nonspecialentries);
      break;
    case GT_SAIN_INTSEQ:
      gt_sain_INTSEQ_induceStypesuffixes2(sainseq,sainseq->seq.array,
                                          suftab,nonspecialentries);
      break;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x50(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x3, %rax
ja 0x2d3cf6
movq 0x8(%rsp), %rax
leaq 0x2b83b6(%rip), %rcx    # 0x58c048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d9b60
jmp 0x2d3cf6
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d9da0
jmp 0x2d3cf6
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2d9ff0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sainbuffer_update
static void gt_sainbuffer_update(GtSainbuffer *buf,
                                 GtUword charidx,
                                 GtUsainindextype value)
{
  const GtUword offset = charidx << buf->log_bufsize;

  buf->values[offset + (GtUword) buf->nextidx[charidx]] = value;
  if ((GtUword) buf->nextidx[charidx] < buf->buf_size - 1)
  {
    buf->nextidx[charidx]++;
  } else
  {
    GtUsainindextype *writeptr = buf->suftab + buf->fillptr[charidx] - 1,
                     *readptr = buf->values + offset;
    const GtUsainindextype *readend = readptr + buf->buf_size;

    while (readptr < readend)
    {
      *(writeptr--) = *(readptr++);
    }
    buf->nextidx[charidx] = 0;
    buf->fillptr[charidx] -= buf->buf_size;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
movl 0x38(%rcx), %ecx
shlq %cl, %rax
movq %rax, -0x20(%rsp)
movl -0x14(%rsp), %edx
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rsp), %rcx
movq -0x8(%rsp), %rsi
movq 0x30(%rsi), %rsi
movq -0x10(%rsp), %rdi
movzwl (%rsi,%rdi,2), %esi
addq %rsi, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2d4dff
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rsp), %rcx
movw (%rax,%rcx,2), %dx
addw $0x1, %dx
movw %dx, (%rax,%rcx,2)
jmp 0x2d4ec3
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq -0x10(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
addq $-0x4, %rax
movq %rax, -0x28(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x20(%rsp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rax
cmpq -0x38(%rsp), %rax
jae 0x2d4e90
movq -0x30(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x30(%rsp)
movl (%rax), %ecx
movq -0x28(%rsp), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, -0x28(%rsp)
movl %ecx, (%rax)
jmp 0x2d4e5c
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rsp), %rcx
movw $0x0, (%rax,%rcx,2)
movq -0x8(%rsp), %rax
movq (%rax), %rsi
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rsp), %rcx
movl (%rax,%rcx,4), %edx
subq %rsi, %rdx
movl %edx, (%rax,%rcx,4)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sainbuffer_flushall
static void gt_sainbuffer_flushall(GtSainbuffer *buf)
{
  GtUword charidx;

  if (buf == NULL)
  {
    return;
  }
  for (charidx = 0; charidx < buf->numofchars; charidx++)
  {
    const GtUsainindextype bufleft = (GtUsainindextype) buf->nextidx[charidx];

    if (bufleft > 0)
    {
      GtUsainindextype *writeptr = buf->suftab + buf->fillptr[charidx] - 1,
                       *readptr = buf->values + (charidx << buf->log_bufsize);
      const GtUsainindextype *readend = readptr + bufleft;

      while (readptr < readend)
      {
        *(writeptr--) = *(readptr++);
      }
      buf->nextidx[charidx] = 0;
      buf->fillptr[charidx] -= bufleft;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
cmpq $0x0, -0x8(%rsp)
jne 0x2d4ee2
jmp 0x2d4ffe
movq $0x0, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2d4ffe
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rsp), %rcx
movzwl (%rax,%rcx,2), %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jbe 0x2d4fe9
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq -0x10(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
addq $-0x4, %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rdx
movq -0x8(%rsp), %rcx
movl 0x38(%rcx), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl -0x14(%rsp), %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x30(%rsp), %rax
jae 0x2d4fbb
movq -0x28(%rsp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x28(%rsp)
movl (%rax), %ecx
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $-0x4, %rdx
movq %rdx, -0x20(%rsp)
movl %ecx, (%rax)
jmp 0x2d4f87
movq -0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rsp), %rcx
movw $0x0, (%rax,%rcx,2)
movl -0x14(%rsp), %esi
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rsp), %rcx
movl (%rax,%rcx,4), %edx
subl %esi, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x2d4feb
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x2d4eeb
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sainbuffer_delete
static void gt_sainbuffer_delete(GtSainbuffer *buf)
{
  if (buf != NULL)
  {
    gt_free(buf->values);
    gt_free(buf->nextidx);
    gt_free(buf);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2d5053
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x2b704d(%rip), %rsi    # 0x58c068
movl $0x1d6, %edx            # imm = 0x1D6
callq 0xe88c0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x2b7034(%rip), %rsi    # 0x58c068
movl $0x1d7, %edx            # imm = 0x1D7
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x2b701f(%rip), %rsi    # 0x58c068
movl $0x1d8, %edx            # imm = 0x1D8
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sainseq_getchar
static GtUword gt_sainseq_getchar(const GtSainseq *sainseq,
                                  GtUword position)
{
  gt_assert(position < sainseq->totallength);
#ifdef GT_SAIN_WITHCOUNTS
  gt_sain_countcharaccess++;
#endif
  switch (sainseq->seqtype)
  {
    case GT_SAIN_PLAINSEQ:
      return (GtUword) sainseq->seq.plainseq[position];
    case GT_SAIN_INTSEQ:
      return (GtUword) sainseq->seq.array[position];
    case GT_SAIN_ENCSEQ:
      {
        GtUchar cc = gt_encseq_get_encoded_char(sainseq->seq.encseq,
                                                position,
                                                sainseq->readmode);
        return GT_ISSPECIAL(cc) ? GT_UNIQUEINT(position) : (GtUword) cc;
      }
    case GT_SAIN_BARE_ENCSEQ:
      {
        GtUchar cc = sainseq->seq.plainseq[position];
        return GT_ISSPECIAL(cc) ? GT_UNIQUEINT(position) : (GtUword) cc;
      }
  }
#ifndef S_SPLINT_S
  return 0;
#endif
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x2d7885
movq 0x36474c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x23e7b5(%rip), %rsi    # 0x516013
leaq 0x2b4e9d(%rip), %rdx    # 0x58c702
leaq 0x2b4eb6(%rip), %rcx    # 0x58c722
leaq 0x2b47f5(%rip), %r8     # 0x58c068
movl $0x136, %r9d            # imm = 0x136
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d7887
movq 0x28(%rsp), %rax
movl 0x50(%rax), %eax
movq %rax, 0x10(%rsp)
subq $0x3, %rax
ja 0x2d7983
movq 0x10(%rsp), %rax
leaq 0x2b47ae(%rip), %rcx    # 0x58c058
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movq %rax, 0x30(%rsp)
jmp 0x2d798c
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, 0x30(%rsp)
jmp 0x2d798c
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
movl 0x40(%rax), %edx
callq 0xa9da0
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2d7927
movq 0x20(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, 0x8(%rsp)
jmp 0x2d7931
movzbl 0x1f(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2d798c
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x20(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0x1e(%rsp)
movzbl 0x1e(%rsp), %eax
cmpl $0xfe, %eax
jl 0x2d796f
movq 0x20(%rsp), %rax
addq $0x100, %rax            # imm = 0x100
movq %rax, (%rsp)
jmp 0x2d7978
movzbl 0x1e(%rsp), %eax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2d798c
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-sain.c
// Function: gt_sain_compare_suffixes
static int gt_sain_compare_suffixes(const GtSainseq *sainseq,
                                    GtUword start1,
                                    GtUword start2)
{
  gt_assert(start1 <= sainseq->totallength &&
            start2 <= sainseq->totallength &&
            start1 != start2);

  while (true)
  {
    GtUword cc1, cc2;

    if (start1 == sainseq->totallength)
    {
      gt_assert(start1 > start2);
      return 1;
    }
    if (start2 == sainseq->totallength)
    {
      gt_assert(start1 < start2);
      return -1;
    }
    cc1 = gt_sainseq_getchar(sainseq,start1);
    cc2 = gt_sainseq_getchar(sainseq,start2);
    if (cc1 < cc2)
    {
      return -1;
    }
    if (cc1 > cc2)
    {
      return 1;
    }
    start1++;
    start2++;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq (%rcx), %rax
ja 0x2d932d
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq (%rcx), %rax
ja 0x2d932d
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jne 0x2d9365
movq 0x362c6c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x23ccd5(%rip), %rsi    # 0x516013
leaq 0x2b3671(%rip), %rdx    # 0x58c9b6
leaq 0x2b39d1(%rip), %rcx    # 0x58cd1d
leaq 0x2b2d15(%rip), %r8     # 0x58c068
movl $0x3d5, %r9d            # imm = 0x3D5
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d9367
jmp 0x2d9369
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x2d93cd
jmp 0x2d937a
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x2d93be
movq 0x362c13(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x23cc7c(%rip), %rsi    # 0x516013
leaq 0x2b3693(%rip), %rdx    # 0x58ca31
leaq 0x2b3978(%rip), %rcx    # 0x58cd1d
leaq 0x2b2cbc(%rip), %r8     # 0x58c068
movl $0x3dd, %r9d            # imm = 0x3DD
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d93c0
movl $0x1, 0x34(%rsp)
jmp 0x2d94a3
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x2d942e
jmp 0x2d93de
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
jb 0x2d9422
movq 0x362baf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x23cc18(%rip), %rsi    # 0x516013
leaq 0x2b363f(%rip), %rdx    # 0x58ca41
leaq 0x2b3914(%rip), %rcx    # 0x58cd1d
leaq 0x2b2c58(%rip), %r8     # 0x58c068
movl $0x3e2, %r9d            # imm = 0x3E2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d9424
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d94a3
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2d7830
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2d7830
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x2d946c
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d94a3
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jbe 0x2d9482
movl $0x1, 0x34(%rsp)
jmp 0x2d94a3
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2d9369
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_special_singleSinduction2
static void gt_sain_special_singleSinduction2(const GtSainseq *sainseq,
                                              GtSsainindextype *suftab,
                                              GtSsainindextype position,
                                              GT_UNUSED GtUword
                                                nonspecialentries)
{
  GtUword currentcc;

  currentcc = gt_sainseq_getchar(sainseq,(GtUword) --position);
  if (currentcc < sainseq->numofchars)
  {
    GtUsainindextype putidx = --sainseq->bucketfillptr[currentcc];

    gt_assert((GtUword) putidx < nonspecialentries);
    suftab[putidx] = (position == 0 ||
                      gt_sainseq_getchar(sainseq,
                                         (GtUword)
                                         (position-1)) > currentcc)
                      ? ~position : position;
#ifdef SAINSHOWSTATE
    printf("end S-induce: suftab["GT_WU"]="GT_WD"\n",putidx,suftab[putidx]);
#endif
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x24(%rsp)
movslq %eax, %rsi
callq 0x2d7830
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2da31f
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x10(%rsp), %rdx
movl (%rcx,%rdx,4), %eax
addl $-0x1, %eax
movl %eax, (%rcx,%rdx,4)
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpq 0x18(%rsp), %rax
jb 0x2da2d6
movq 0x361cfb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x23bd64(%rip), %rsi    # 0x516013
leaq 0x2b2bea(%rip), %rdx    # 0x58cea0
leaq 0x2b2c08(%rip), %rcx    # 0x58cec5
leaq 0x2b1da4(%rip), %r8     # 0x58c068
movl $0x252, %r9d            # imm = 0x252
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2da2d8
cmpl $0x0, 0x24(%rsp)
je 0x2da2fa
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x2d7830
cmpq 0x10(%rsp), %rax
jbe 0x2da307
movl 0x24(%rsp), %eax
xorl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2da30f
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %edx
movq 0x28(%rsp), %rax
movl 0xc(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-shortreadsort.c
// Function: gt_shortreadsort_size_perbucketentry
static size_t gt_shortreadsort_size_perbucketentry(bool firstcodes,
                                                   GtUword maxremain)
{
  return (firstcodes ? sizeof (uint16_t) : 0) +
         sizeof (GtShortreadsort) + sizeof (GtUword) +
         sizeof (GtTwobitencoding) *
         gt_shortreadsort_encoding_factor(maxremain);
}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movq %rsi, 0x8(%rsp)
movzbl 0x17(%rsp), %ecx
andl $0x1, %ecx
movl %ecx, %eax
leal 0x18(%rax,%rax), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x2dd290
movsd (%rsp), %xmm1
movsd 0x273c20(%rip), %xmm2   # 0x54e260
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x23e711(%rip), %xmm1   # 0x518d70
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)