LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_encseq_sortsuffixes
GtUsainindextype *gt_sain_encseq_sortsuffixes(const GtEncseq *encseq,
                                              GtReadmode readmode,
                                              bool intermediatecheck,
                                              bool finalcheck,
                                              GtLogger *logger,
                                              GtTimer *timer)
{
  GtUword nonspecialentries, suftabentries, totallength;
  GtUsainindextype *suftab;
  GtSainseq *sainseq;

  totallength = gt_encseq_total_length(encseq);
  nonspecialentries = totallength - gt_encseq_specialcharacters(encseq);
  suftabentries = totallength+1;
  suftab = (GtUsainindextype *) gt_calloc((size_t) suftabentries,
                                          sizeof *suftab);
  sainseq = gt_sainseq_new_from_encseq(encseq,readmode);
  gt_sain_rec_sortsuffixes(0,
                           sainseq,
                           suftab,
                           0,
                           nonspecialentries,
                           suftabentries,
                           intermediatecheck,
                           finalcheck,
                           logger,
                           timer);
#ifdef GT_SAIN_WITHCOUNTS
  printf("countcharaccess="GT_WU" (%.2f)\n",gt_sain_countcharaccess,
          (double) gt_sain_countcharaccess/sainseq->totallength);
#endif
  gt_sainseq_delete(sainseq);
  return suftab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x28(%rsp)
movq %r8, 0x30(%rsp)
movl %ecx, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movl %esi, %ebx
movq %rdi, %r14
callq 0xec1d8
movq %rax, %r13
movq %r14, %rdi
callq 0xf0b87
movq %rax, 0x10(%rsp)
leaq 0x1(%r13), %rdi
leaq 0x1c7c85(%rip), %rbp    # 0x3c2708
movl $0x4, %esi
movq %rdi, 0x18(%rsp)
movq %rbp, %rdx
movl $0x638, %ecx            # imm = 0x638
callq 0x1093ef
movq %rax, 0x20(%rsp)
movl $0x58, %edi
movq %rbp, %rsi
movl $0x74, %edx
callq 0x1092b2
movq %rax, %rbp
movl $0x2, 0x50(%rax)
movq %r14, 0x38(%rax)
movq $0x0, 0x48(%rax)
movl %ebx, 0x40(%rax)
movq %r14, %rdi
callq 0xec1d8
movq %rax, (%rbp)
movq %r14, %rdi
callq 0xf02b7
movl %eax, %eax
movq %rax, 0x8(%rbp)
movq (%rbp), %rdx
leaq 0x100(%rdx), %rsi
movq %rbp, %rdi
callq 0x1fce54
cmpq $0x0, 0x8(%rbp)
je 0x1fab34
andl $-0x2, %ebx
movb $0x3, %r12b
xorl %r15d, %r15d
cmpl $0x2, %ebx
movzbl %r12b, %r12d
movl %r15d, %eax
cmovel %r12d, %eax
movzbl %al, %esi
movq %r14, %rdi
callq 0xf02fa
movq 0x18(%rbp), %rcx
movl %eax, (%rcx,%r15,4)
incq %r15
decb %r12b
cmpq 0x8(%rbp), %r15
jb 0x1fab07
subq 0x10(%rsp), %r13
movzbl 0x8(%rsp), %eax
movzbl 0xc(%rsp), %r10d
xorl %edi, %edi
movq %rbp, %rsi
movq 0x20(%rsp), %rbx
movq %rbx, %rdx
xorl %ecx, %ecx
movq %r13, %r8
movq 0x18(%rsp), %r9
pushq 0x28(%rsp)
pushq 0x38(%rsp)
pushq %rax
pushq %r10
callq 0x1fab89
addq $0x20, %rsp
movq %rbp, %rdi
callq 0x1fc94e
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sainseq_delete
static void gt_sainseq_delete(GtSainseq *sainseq)
{
  if (sainseq != NULL)
  {
    if (!sainseq->bucketfillptrpoints2suftab)
    {
      gt_free(sainseq->bucketfillptr);
    }
    if (!sainseq->bucketsizepoints2suftab)
    {
      gt_free(sainseq->bucketsize);
    }
    if (!sainseq->roundtablepoints2suftab)
    {
      gt_free(sainseq->roundtable);
    }
    if (sainseq->seqtype != GT_SAIN_INTSEQ)
    {
      gt_free(sainseq->sstarfirstcharcount);
    }
    gt_free(sainseq);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1fc9dc
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x54(%rdi)
jne 0x1fc976
movq 0x20(%rbx), %rdi
leaq 0x1c5d9c(%rip), %rsi    # 0x3c2708
movl $0x11d, %edx            # imm = 0x11D
callq 0x109670
cmpb $0x0, 0x55(%rbx)
jne 0x1fc991
movq 0x18(%rbx), %rdi
leaq 0x1c5d81(%rip), %rsi    # 0x3c2708
movl $0x121, %edx            # imm = 0x121
callq 0x109670
cmpb $0x0, 0x56(%rbx)
jne 0x1fc9ac
movq 0x30(%rbx), %rdi
leaq 0x1c5d66(%rip), %rsi    # 0x3c2708
movl $0x125, %edx            # imm = 0x125
callq 0x109670
cmpl $0x1, 0x50(%rbx)
je 0x1fc9c7
movq 0x28(%rbx), %rdi
leaq 0x1c5d4b(%rip), %rsi    # 0x3c2708
movl $0x129, %edx            # imm = 0x129
callq 0x109670
leaq 0x1c5d3a(%rip), %rsi    # 0x3c2708
movq %rbx, %rdi
movl $0x12b, %edx            # imm = 0x12B
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_plain_sortsuffixes
GtUsainindextype *gt_sain_plain_sortsuffixes(const GtUchar *plainseq,
                                             GtUword len,
                                             bool intermediatecheck,
                                             bool finalcheck,
                                             GtLogger *logger,
                                             GtTimer *timer)
{
  GtUword suftabentries;
  GtUsainindextype *suftab;
  GtSainseq *sainseq;

  suftabentries = len+1;
  suftab = (GtUsainindextype *) gt_calloc((size_t) suftabentries,
                                          sizeof *suftab);
  sainseq = gt_sainseq_new_from_plainseq(plainseq,len);
  gt_sain_rec_sortsuffixes(0,
                           sainseq,
                           suftab,
                           0,
                           sainseq->totallength,
                           suftabentries,
                           intermediatecheck,
                           finalcheck,
                           logger,
                           timer);
#ifdef GT_SAIN_WITHCOUNTS
  printf("countcharaccess="GT_WU" (%.2f)\n",gt_sain_countcharaccess,
          (double) gt_sain_countcharaccess/sainseq->totallength);
#endif
  gt_sainseq_delete(sainseq);
  return suftab;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, 0x10(%rsp)
movl %ecx, 0x4(%rsp)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r13
leaq 0x1(%rsi), %r12
leaq 0x1c5baf(%rip), %rbx    # 0x3c2708
movl $0x4, %esi
movq %r12, %rdi
movq %rbx, %rdx
movl $0x67e, %ecx            # imm = 0x67E
callq 0x1093ef
movq %rax, %r15
movl $0x58, %edi
movq %rbx, %rsi
movl $0x93, %edx
callq 0x1092b2
movq %rax, %rbx
xorl %eax, %eax
movl %eax, 0x50(%rbx)
movq %r13, 0x38(%rbx)
movq %r14, (%rbx)
movq $0x100, 0x8(%rbx)       # imm = 0x100
movq $0x0, 0x48(%rbx)
movl %eax, 0x40(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1fce54
testq %r14, %r14
jle 0x1fcbd5
movq 0x18(%rbx), %rax
movq 0x38(%rbx), %rcx
movzbl (%rcx), %edx
incl (%rax,%rdx,4)
incq %rcx
movq 0x38(%rbx), %rdx
addq %r14, %rdx
cmpq %rdx, %rcx
jb 0x1fcbc0
movq (%rbx), %r8
movzbl 0x4(%rsp), %eax
movzbl %bpl, %r10d
xorl %edi, %edi
movq %rbx, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
movq %r12, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq %rax
pushq %r10
callq 0x1fab89
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x1fc94e
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_suf_lcp_iterator_delete
void gt_sain_suf_lcp_iterator_delete(GtSainSufLcpIterator *suflcpiterator)
{
  if (suflcpiterator != NULL)
  {
    gt_bare_encseq_delete(suflcpiterator->bare_encseq);
    gt_free(suflcpiterator->suftab);
    gt_free(suflcpiterator->plcptab);
    gt_free(suflcpiterator);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1fcdee
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x192d4c
movq (%rbx), %rdi
leaq 0x1c594f(%rip), %r14    # 0x3c2708
movq %r14, %rsi
movl $0x6ef, %edx            # imm = 0x6EF
callq 0x109670
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x6f0, %edx            # imm = 0x6F0
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6f1, %edx            # imm = 0x6F1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_suf_lcp_iterator_nonspecials
GtUword gt_sain_suf_lcp_iterator_nonspecials(const GtSainSufLcpIterator
                                                   *suflcpiterator)
{
  GtUword totallength;

  gt_assert(suflcpiterator != NULL);
  totallength = gt_bare_encseq_total_length(suflcpiterator->bare_encseq);
  return totallength -
         gt_bare_encseq_specialcharacters(suflcpiterator->bare_encseq);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1fce1e
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x19326b
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x1932a9
subq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x7c894
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rsi, %rsi
je 0x1fce4e
movq 0x20(%rsi), %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x20(%rsi)
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
movl (%rdx,%rcx,4), %eax
movl 0x4(%rdx,%rcx,4), %ecx
movl (%rsi,%rcx,4), %ecx
movq %rcx, (%rdi)
retq
pushq %rax
callq 0x7c8cd
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1c5898(%rip), %r12    # 0x3c2708
movl $0x4, %esi
movq %r12, %rdx
movl $0x5a, %ecx
callq 0x1093ef
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rdi
shlq $0x2, %rdi
movq %r12, %rsi
movl $0x5d, %edx
callq 0x1092b2
movq %rax, 0x20(%rbx)
movq 0x8(%rbx), %rdi
shrq $0x3e, %r15
cmpl $0x3, %r15d
setb %al
cmpq $0x401, %r14            # imm = 0x401
setae %cl
andb %al, %cl
leaq (%rdi,%rdi), %rax
cmpq %r14, %rax
setbe %al
andb %cl, %al
cmpb $0x1, %al
jne 0x1fcee1
shlq $0x3, %rdi
leaq 0x1c5833(%rip), %rsi    # 0x3c2708
movl $0x62, %edx
callq 0x1092b2
jmp 0x1fcee3
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq 0x8(%rbx), %rdi
leaq 0x1c5816(%rip), %rdx    # 0x3c2708
movl $0x4, %esi
movl $0x6a, %ecx
callq 0x1093ef
movq %rax, 0x28(%rbx)
movw $0x0, 0x54(%rbx)
movb $0x0, 0x56(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_moveSstar2front
static void gt_sain_moveSstar2front(GtUword countSstartype,
                                    GtSsainindextype *suftab,
                                    GT_UNUSED GtUword nonspecialentries)
{
  GtUword readidx, writeidx = 0;
  GtSsainindextype position;

  for (readidx = 0; (position = suftab[readidx]) < 0; readidx++)
  {
    position = ~position;
    suftab[readidx] = position;
    gt_assert ((readidx + 1) < nonspecialentries);
  }
  if (readidx < countSstartype)
  {
    for (writeidx = readidx, readidx++; /* Nothing */; readidx++)
    {
      gt_assert (readidx < nonspecialentries);
      if ((position = suftab[readidx]) < 0)
      {
        position = ~position;
        gt_assert(writeidx < readidx);
        suftab[writeidx++] = position;
        suftab[readidx] = 0;
        if (writeidx == countSstartype)
        {
          break;
        }
      } else
      {
        suftab[readidx] = 0;
      }
    }
  } else
  {
    writeidx = readidx;
  }
  gt_assert(writeidx == countSstartype);
}

// Assembly:
pushq %rax
cmpq $0x1, %rdx
movq %rdx, %rcx
adcq $0x0, %rcx
xorl %eax, %eax
movl (%rsi,%rax,4), %r8d
testl %r8d, %r8d
jns 0x1fcf46
notl %r8d
movl %r8d, (%rsi,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x1fcf29
callq 0x7c9b1
cmpq %rdi, %rax
jae 0x1fcf86
leaq 0x1(%rax), %rcx
cmpq %rdx, %rcx
jae 0x1fcf8d
movl (%rsi,%rcx,4), %r8d
testl %r8d, %r8d
js 0x1fcf66
movl $0x0, (%rsi,%rcx,4)
jmp 0x1fcf81
cmpq %rcx, %rax
jae 0x1fcf92
notl %r8d
movl %r8d, (%rsi,%rax,4)
incq %rax
movl $0x0, (%rsi,%rcx,4)
cmpq %rdi, %rax
je 0x1fcf86
incq %rcx
jmp 0x1fcf4f
cmpq %rdi, %rax
jne 0x1fcf97
popq %rax
retq
callq 0x7c93f
callq 0x7c906
callq 0x7c978
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, (%rsp)
testq %rdx, %rdx
je 0x1fd2f0
movq %rdi, %r15
movl $0x1, %r12d
movq %rsi, 0x10(%rsp)
movl -0x4(%rsi,%r12,4), %r13d
movl (%rsi,%r12,4), %ebp
cmpl %ebp, %r13d
je 0x1fd309
movq (%r15), %rax
cmpq %r13, %rax
jb 0x1fd309
cmpq %rbp, %rax
jb 0x1fd309
leaq (%rsi,%r12,4), %rax
movq %rax, 0x8(%rsp)
movq (%r15), %rax
cmpq %rax, %r13
jne 0x1fd28f
cmpq %rbp, %r13
jbe 0x1fd2ff
movl $0x1, %r14d
jmp 0x1fd2bf
cmpq %rax, %rbp
jne 0x1fd29b
cmpq %rbp, %r13
jb 0x1fd2b9
jmp 0x1fd304
movq %r15, %rdi
movq %r13, %rsi
callq 0x1fe6aa
movq %rax, %rbx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x1fe6aa
cmpq %rax, %rbx
jae 0x1fd2c7
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
xorl %eax, %eax
testb %al, %al
jne 0x1fd27a
jmp 0x1fd2d3
ja 0x1fd287
incq %r13
incq %rbp
movb $0x1, %al
jmp 0x1fd2c1
cmpl $-0x1, %r14d
jne 0x1fd30e
leaq 0x1(%r12), %rax
cmpq (%rsp), %r12
movq %rax, %r12
movq 0x10(%rsp), %rsi
jne 0x1fd24a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7cb07
callq 0x7cace
callq 0x7cb80
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x7cb40
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sainbuffer_new
static GtSainbuffer *gt_sainbuffer_new(GtUsainindextype *suftab,
                                       GtUsainindextype *fillptr,
                                       GtUword numofchars,
                                       GtUword totallength,
                                       GtLogger *logger)
{
  if (numofchars <= UCHAR_MAX+1)
  {
    GtSainbuffer *buf = (GtSainbuffer *) gt_malloc(sizeof (*buf));

    buf->size = sizeof (*buf);
    buf->fillptr = fillptr;
    buf->suftab = suftab;
    buf->log_bufsize = 18 - (sizeof (GtUsainindextype) == (size_t) 4 ? 1 : 2) -
                             (int) gt_determinebitspervalue(numofchars);
    buf->buf_size = 1UL << buf->log_bufsize;
    buf->numofchars = numofchars;
    gt_assert(buf->buf_size <= UINT16_MAX);
    buf->cachesize = numofchars << buf->log_bufsize;
    buf->size += sizeof (*buf->values) * buf->cachesize;
    buf->size += sizeof (*buf->nextidx) * numofchars;
    if ((GtUword) buf->size * 10UL >= totallength)
    {
      gt_free(buf);
      buf = NULL;
    } else
    {
      buf->values = (GtUsainindextype *)
                    gt_malloc(sizeof (*buf->values) * buf->cachesize);
      buf->nextidx = gt_calloc((size_t) numofchars,sizeof (*buf->nextidx));
      gt_logger_log(logger,"used buffer of "GT_WU" bytes (bufsize="GT_WU")",
                         (GtUword) buf->size,buf->buf_size);
    }
    return buf;
  } else
  {
    return NULL;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x100, %rdx            # imm = 0x100
ja 0x1fd6bc
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %r13
leaq 0x1c5121(%rip), %rsi    # 0x3c2708
movl $0x48, %edi
movl $0x17d, %edx            # imm = 0x17D
callq 0x1092b2
movq %rax, %rbx
movq $0x48, 0x40(%rax)
movq %rbp, 0x20(%rax)
movq %r13, 0x28(%rax)
movq %r15, %rdi
callq 0x10af48
movl $0x11, %ecx
subl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movl %ecx, 0x38(%rbx)
movq %rax, (%rbx)
movq %r15, 0x8(%rbx)
cmpl $0x10, %ecx
jae 0x1fd6d0
movq %r15, %rdi
shlq %cl, %rdi
movq %rdi, 0x10(%rbx)
leaq (%r15,%r15), %rax
leaq (%rax,%rdi,4), %rax
addq 0x40(%rbx), %rax
movq %rax, 0x40(%rbx)
addq %rax, %rax
leaq (%rax,%rax,4), %rax
cmpq %r12, %rax
jae 0x1fd6a8
shlq $0x2, %rdi
leaq 0x1c50a4(%rip), %r12    # 0x3c2708
movq %r12, %rsi
movl $0x191, %edx            # imm = 0x191
callq 0x1092b2
movq %rax, 0x18(%rbx)
movl $0x2, %esi
movq %r15, %rdi
movq %r12, %rdx
movl $0x192, %ecx            # imm = 0x192
callq 0x1093ef
movq %rax, 0x30(%rbx)
movq (%rbx), %rcx
movq 0x40(%rbx), %rdx
leaq 0x1c5446(%rip), %rsi    # 0x3c2ae2
movq %r14, %rdi
xorl %eax, %eax
callq 0x10906e
jmp 0x1fd6be
leaq 0x1c5059(%rip), %rsi    # 0x3c2708
movq %rbx, %rdi
movl $0x18c, %edx            # imm = 0x18C
callq 0x109670
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7cd0f
// File: /workspace/github_c_makefile_star2_O1/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:
movb 0x38(%rdi), %cl
movq %rsi, %r8
shlq %cl, %r8
movq 0x30(%rdi), %rax
movzwl (%rax,%rsi,2), %r9d
shlq $0x2, %r8
addq 0x18(%rdi), %r8
movl %edx, (%r8,%r9,4)
movq (%rdi), %rcx
leaq -0x1(%rcx), %rdx
cmpq %r9, %rdx
jbe 0x1fd708
incl %r9d
movw %r9w, (%rax,%rsi,2)
retq
movq 0x20(%rdi), %rdx
testq %rcx, %rcx
jle 0x1fd738
leaq (%r8,%rcx,4), %r9
movq 0x28(%rdi), %rdi
movl (%rdx,%rsi,4), %r10d
leaq (%rdi,%r10,4), %rdi
addq $-0x4, %rdi
movl (%r8), %r10d
addq $0x4, %r8
movl %r10d, (%rdi)
addq $-0x4, %rdi
cmpq %r9, %r8
jb 0x1fd725
movw $0x0, (%rax,%rsi,2)
subl %ecx, (%rdx,%rsi,4)
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x1fd7b3
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1fd7b3
pushq %rbx
movq 0x30(%rdi), %rdx
xorl %esi, %esi
movzwl (%rdx,%rsi,2), %r8d
testl %r8d, %r8d
je 0x1fd7aa
movq 0x20(%rdi), %r9
movb 0x38(%rdi), %cl
movq %rsi, %r10
shlq %cl, %r10
movq 0x28(%rdi), %r11
shlq $0x2, %r10
addq 0x18(%rdi), %r10
movl %r8d, %ecx
leaq (%r10,%rcx,4), %rcx
movl (%r9,%rsi,4), %ebx
leaq (%r11,%rbx,4), %r11
addq $-0x4, %r11
movl (%r10), %ebx
addq $0x4, %r10
movl %ebx, (%r11)
addq $-0x4, %r11
cmpq %rcx, %r10
jb 0x1fd78d
movw $0x0, (%rdx,%rsi,2)
subl %r8d, (%r9,%rsi,4)
incq %rsi
cmpq %rax, %rsi
jne 0x1fd757
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x1fd800
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x1c4f3d(%rip), %r14    # 0x3c2708
movq %r14, %rsi
movl $0x1d6, %edx            # imm = 0x1D6
callq 0x109670
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x1d7, %edx            # imm = 0x1D7
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1d8, %edx            # imm = 0x1D8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_special_singleSinduction1
static void gt_sain_special_singleSinduction1(GtSainseq *sainseq,
                                              GtSsainindextype *suftab,
                                              GtSsainindextype position)
{
  GtUword currentcc = gt_sainseq_getchar(sainseq,(GtUword) position);

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

    gt_assert(position > 0);
    leftcontextcc = gt_sainseq_getchar(sainseq,(GtUword) --position);
    if (sainseq->roundtable != NULL)
    {
      GtUword t = (currentcc << 1) |
                  (leftcontextcc > currentcc ? 1UL : 0);

      gt_assert (sainseq->roundtable[t] <= sainseq->currentround);
      if (sainseq->roundtable[t] < sainseq->currentround)
      {
        sainseq->roundtable[t] = sainseq->currentround;
      }
      position += sainseq->totallength;
    }
    suftab[putidx] = (leftcontextcc > currentcc) ? ~(position+1) : position;
#ifdef SAINSHOWSTATE
    printf("end S-induce: suftab["GT_WU"]="GT_WD"\n",putidx,suftab[putidx]);
#endif
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r12
movslq %edx, %rsi
callq 0x1fe6aa
cmpq 0x8(%r12), %rax
jae 0x1fe539
movq %rax, %r15
movq 0x20(%r12), %rax
movl (%rax,%r15,4), %ebp
decl %ebp
movl %ebp, (%rax,%r15,4)
testl %r14d, %r14d
jle 0x1fe542
decl %r14d
movq %r12, %rdi
movq %r14, %rsi
callq 0x1fe6aa
movq 0x30(%r12), %rcx
testq %rcx, %rcx
je 0x1fe525
xorl %edx, %edx
cmpq %r15, %rax
seta %dl
leaq (%rdx,%r15,2), %rdx
movl 0x10(%r12), %esi
cmpl %esi, (%rcx,%rdx,4)
ja 0x1fe547
jae 0x1fe521
movl %esi, (%rcx,%rdx,4)
addl (%r12), %r14d
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
subl %r14d, %ecx
cmpq %r15, %rax
cmovbel %r14d, %ecx
movl %ebp, %eax
movl %ecx, (%rbx,%rax,4)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x7d3ec
callq 0x7d425
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
cmpq %rsi, (%rdi)
jbe 0x1fe725
movl 0x50(%rdi), %eax
cmpq $0x3, %rax
ja 0x1fe721
movq %rsi, %rbx
leaq 0x1c4035(%rip), %rcx    # 0x3c26f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x38(%rdi), %rax
movzbl (%rax,%rbx), %eax
jmp 0x1fe723
movq 0x38(%rdi), %rax
movl 0x40(%rdi), %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xec1f8
addq $0x100, %rbx            # imm = 0x100
cmpb $-0x2, %al
movzbl %al, %eax
cmovaeq %rbx, %rax
jmp 0x1fe723
movq 0x38(%rdi), %rax
movzbl (%rax,%rbx), %eax
addq $0x100, %rbx            # imm = 0x100
cmpq $0xfe, %rax
cmovbq %rax, %rbx
movq %rbx, %rax
jmp 0x1fe723
movq 0x38(%rdi), %rax
movl (%rax,%rbx,4), %eax
jmp 0x1fe723
xorl %eax, %eax
popq %rbx
retq
callq 0x7d4d0
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r13
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leal -0x1(%r14), %ebp
movslq %ebp, %rsi
callq 0x1fe6aa
cmpq 0x8(%r15), %rax
jae 0x1fe792
movq %rax, %r12
movq %rbx, (%rsp)
movq 0x20(%r15), %rax
movl (%rax,%r12,4), %ebx
decl %ebx
movl %ebx, (%rax,%r12,4)
cmpq %r13, %rbx
jae 0x1fe7a1
testl %ebp, %ebp
je 0x1fe785
leal -0x2(%r14), %eax
movslq %eax, %rsi
movq %r15, %rdi
callq 0x1fe6aa
cmpq %r12, %rax
jbe 0x1fe78b
negl %r14d
movl %r14d, %ebp
movq (%rsp), %rax
movl %ebp, (%rax,%rbx,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7d509
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-shortreadsort.c
// Function: gt_shortreadsort_size
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:
testl %edi, %edi
jne 0x1fe912
movsd 0x1c4cf0(%rip), %xmm0   # 0x3c3600
jmp 0x1fe91a
movsd 0x1c4cde(%rip), %xmm0   # 0x3c35f8
movsd 0x150906(%rip), %xmm1   # 0x34f228
cmpq $0x41, %rdx
jb 0x1fe935
shrq $0x6, %rdx
cvtsi2sd %rdx, %xmm2
addsd %xmm2, %xmm1
mulsd 0x186753(%rip), %xmm1   # 0x385090
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x1523cb(%rip), %xmm1   # 0x350d20
cvttsd2si %xmm1, %rax
andq %rdx, %rax
orq %rcx, %rax
imulq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-shortreadsort.c
// Function: gt_shortreadsort_new
GtShortreadsortworkinfo *gt_shortreadsort_new(GtUword maxwidth,
                                              GtUword maxremain,
                                              GtReadmode readmode,
                                              bool firstcodes,
                                              bool withmediumsizelcps)
{
  GtShortreadsortworkinfo *srsw;

  srsw = gt_malloc(sizeof (*srsw));
  srsw->fwd = GT_ISDIRREVERSE(readmode) ? false : true;
  srsw->complement = GT_ISDIRCOMPLEMENT(readmode) ? true : false;
  srsw->sssplcpvalues = NULL;
  srsw->sumofstoredvalues = 0;
  srsw->currentbucketsize = 0;
  srsw->shortreadsorttable = NULL;
  srsw->mediumsizelcpvalues = NULL;
  srsw->withmediumsizelcps = withmediumsizelcps;
  srsw->seqnum_relpos_bucket = NULL;
  GT_INITARRAY(&srsw->tbereservoir,GtTwobitencoding);
  if (maxwidth > 0)
  {
    gt_shortreadsort_resize(srsw,firstcodes,maxwidth,maxremain);
  }
  return srsw;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1c4c1e(%rip), %rsi    # 0x3c3608
movl $0x58, %edi
movl $0x8e, %edx
callq 0x1092b2
movq %rax, %r15
movl %r13d, %eax
andl $-0x3, %eax
cmpl $0x1, %eax
setne 0x50(%r15)
andl $-0x2, %r13d
cmpl $0x2, %r13d
sete 0x51(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movups %xmm0, 0x40(%r15)
movb %r12b, 0x52(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x28(%r15)
testq %r14, %r14
je 0x1fea50
movzbl %bpl, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1fea62
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-shortreadsort.c
// Function: gt_shortreadsort_delete
void gt_shortreadsort_delete(GtShortreadsortworkinfo *srsw)
{
  if (srsw != NULL)
  {
    gt_free(srsw->shortreadsorttable);
    srsw->shortreadsorttable = NULL;
    gt_free(srsw->mediumsizelcpvalues);
    srsw->mediumsizelcpvalues = NULL;
    gt_free(srsw->seqnum_relpos_bucket);
    srsw->seqnum_relpos_bucket = NULL;
    GT_FREEARRAY(&srsw->tbereservoir,GtTwobitencoding);
    gt_free(srsw);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x1fec42
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x1c4a49(%rip), %r14    # 0x3c3608
movq %r14, %rsi
movl $0xa9, %edx
callq 0x109670
xorl %r15d, %r15d
movq %r15, (%rbx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0xab, %edx
callq 0x109670
movq %r15, 0x10(%rbx)
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0xad, %edx
callq 0x109670
movq %r15, 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1fec29
leaq 0x20(%rbx), %r14
leaq 0x1c49f8(%rip), %rsi    # 0x3c3608
movl $0xaf, %edx
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x1c49d8(%rip), %rsi    # 0x3c3608
movq %rbx, %rdi
movl $0xb0, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: getencseqkmersinsertkmerwithoutspecial
void getencseqkmersinsertkmerwithoutspecial(const GtEncseq *encseq,
                                            GtReadmode readmode,
                                            unsigned int kmersize,
                                            Sfxiterator *sfi)
{
  GtKmercodeiterator *kmercodeiterator;
  const GtKmercode *kmercodeptr;

  kmercodeiterator = gt_kmercodeiterator_encseq_new(encseq,readmode,kmersize,0);
  if (!gt_kmercodeiterator_inputexhausted(kmercodeiterator))
  {
    GtUword position = 0;

    while ((kmercodeptr = gt_kmercodeiterator_encseq_next(kmercodeiterator))
                          != NULL)
    {
      gt_insertkmerwithoutspecial(sfi,position++,kmercodeptr);
    }
    gt_kmercodeiterator_delete(kmercodeiterator);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
xorl %ecx, %ecx
callq 0x1f7dc2
movq %rax, %r14
movq %rax, %rdi
callq 0x1f838f
testb %al, %al
je 0x2001e6
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x1f7f9f
testq %rax, %rax
je 0x200214
xorl %esi, %esi
leaq 0x1(%rsi), %r15
movq %rbx, %rdi
movq %rax, %rdx
callq 0x200221
movq %r14, %rdi
callq 0x1f7f9f
movq %r15, %rsi
testq %rax, %rax
jne 0x2001f5
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1f827b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_sfimarkprefixsuffixbuckets
static void gt_sfimarkprefixsuffixbuckets(void *processinfo,
                                          GT_UNUSED bool firstinrange,
                                          GT_UNUSED GtUword pos,
                                          GtCodetype scancode)
{
  Sfxiterator *sfi = (Sfxiterator *) processinfo;
  GtCodetype checkcode = GT_SCANCODE_TO_PREFIXCODE(sfi,scancode);

  gt_assert(firstinrange);
  if (!GT_ISIBITSET(sfi->markprefixbuckets,checkcode))
  {
    GT_SETIBIT(sfi->markprefixbuckets,checkcode);
  }
#if defined (_LP64) || defined (_WIN64)
  checkcode = GT_SCANCODE_TO_SUFFIXCODE(sfi,scancode);
  if (!GT_ISIBITSET(sfi->marksuffixbuckets,checkcode))
  {
    GT_SETIBIT(sfi->marksuffixbuckets,checkcode);
  }
#endif
}

// Assembly:
testl %esi, %esi
je 0x20214a
movq %rcx, %rax
movb 0x128(%rdi), %cl
movq %rax, %rdx
shrq %cl, %rdx
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
movq 0x130(%rdi), %r8
movq %rdx, %r9
shrq $0x6, %r9
movq (%r8,%r9,8), %r10
movq %rsi, %r11
movl %edx, %ecx
shrq %cl, %r11
testq %r10, %r11
jne 0x20211e
orq %r10, %r11
movq %r11, (%r8,%r9,8)
andq 0x140(%rdi), %rax
movq 0x138(%rdi), %rdx
movq %rax, %rdi
shrq $0x6, %rdi
movq (%rdx,%rdi,8), %r8
movl %eax, %ecx
shrq %cl, %rsi
testq %r8, %rsi
je 0x202142
retq
orq %r8, %rsi
movq %rsi, (%rdx,%rdi,8)
retq
pushq %rax
callq 0x7e63d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_Sfxiterator_bcktab2file
int gt_Sfxiterator_bcktab2file(FILE *fp, Sfxiterator *sfi, GtError *err)
{
  gt_error_check(err);
  gt_assert(sfi != NULL && sfi->bcktab != NULL);
  if (gt_suftabparts_numofparts(sfi->suftabparts) <= 1U)
  {
    int ret = gt_bcktab_flush_to_file(fp,sfi->bcktab,err);
    gt_fa_fclose(fp);
    return ret;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
je 0x202cd5
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x202d1e
testq %r15, %r15
je 0x202d19
cmpq $0x0, 0x78(%r15)
je 0x202d19
movq 0x68(%r15), %rdi
callq 0x1f969d
cmpl $0x1, %eax
ja 0x202d0c
movq 0x78(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x193d7e
movl %eax, %ebp
movq %rbx, %rdi
callq 0x101e80
movl %ebp, %eax
jmp 0x202d0e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x7ebf3
callq 0x7ebba
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_Sfxiterator_longest
GtUword gt_Sfxiterator_longest(const Sfxiterator *sfi)
{
  gt_assert(sfi != NULL);
  if (sfi->sfxstrategy.spmopt_minlength == 0)
  {
    return gt_suffixsortspace_longest(sfi->suffixsortspace);
  } else
  {
    return 0;
  }
}

// Assembly:
testq %rdi, %rdi
je 0x202d3d
cmpl $0x0, 0x50(%rdi)
je 0x202d31
xorl %eax, %eax
retq
movq 0x90(%rdi), %rdi
jmp 0x206361
pushq %rax
callq 0x7ec2c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_checksuffixprefixbuckets
static bool gt_checksuffixprefixbuckets(const Sfxiterator *sfi,
                                        GtCodetype scancode)
{
  GtCodetype prefixcode = GT_SCANCODE_TO_PREFIXCODE(sfi,scancode);
  GtCodetype suffixcode = GT_SCANCODE_TO_SUFFIXCODE(sfi,scancode);

  gt_assert(prefixcode < sfi->spmopt_numofallprefixcodes);
  gt_assert(suffixcode < sfi->spmopt_numofallsuffixcodes);
  return (GT_ISIBITSET(sfi->markprefixbuckets,prefixcode) &&
          GT_ISIBITSET(sfi->marksuffixbuckets,suffixcode)) ? true : false;
}

// Assembly:
pushq %rax
movb 0x128(%rdi), %cl
movq %rsi, %rax
shrq %cl, %rax
cmpq 0x148(%rdi), %rax
jae 0x202db0
andq 0x140(%rdi), %rsi
cmpq 0x150(%rdi), %rsi
jae 0x202db5
movq 0x130(%rdi), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
movq (%rcx,%rdx,8), %rdx
movl %eax, %ecx
shlq %cl, %rdx
shrq $0x3f, %rdx
je 0x202dac
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq 0x138(%rdi), %rdx
movq %rsi, %rdi
movl %esi, %ecx
shrq %cl, %rax
shrq $0x6, %rdi
testq %rax, (%rdx,%rdi,8)
setne %al
jmp 0x202dae
xorl %eax, %eax
popq %rcx
retq
callq 0x7ec65
callq 0x7ec9e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_updateleftborderforspecialkmer
static void gt_updateleftborderforspecialkmer(Sfxiterator *sfi,
                                              unsigned int maxprefixindex,
                                              GtUword position,
                                              unsigned int code)
{
  unsigned int idx;

  gt_assert(sfi->sfxstrategy.spmopt_minlength == 0);
  if (sfi->sfxstrategy.storespecialcodes)
  {
    Codeatposition *spcaptr;
    spcaptr = sfi->spaceCodeatposition + sfi->nextfreeCodeatposition++;
    spcaptr->maxprefixindex = maxprefixindex;
    spcaptr->code = code;
    spcaptr->position = position;
  }
  for (idx=maxprefixindex; idx>=1U; idx--)
  {
    gt_bcktab_leftborder_addcode(sfi->leftborder,(GtCodetype) code);
    code = ((code << 2) | 3U) & sfi->kmerfastmaskright;
  }
}

// Assembly:
pushq %rax
cmpl $0x0, 0x50(%rdi)
jne 0x204d43
cmpb $0x1, 0x55(%rdi)
jne 0x204cf6
movq 0x100(%rdi), %rax
movq 0x108(%rdi), %r8
leaq 0x1(%rax), %r9
movq %r9, 0x100(%rdi)
shlq $0x4, %rax
movl %esi, %r9d
andl $0xf, %r9d
movl %ecx, %r10d
shll $0x4, %r10d
orl %r9d, %r10d
movl %r10d, (%r8,%rax)
movq %rdx, 0x8(%r8,%rax)
testl %esi, %esi
je 0x204d3c
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x204d48
movq 0x8(%rax), %rdx
movl %ecx, %ecx
testq %rdx, %rdx
je 0x204d17
incq (%rdx,%rcx,8)
jmp 0x204d2b
movq (%rax), %r8
movl (%r8,%rcx,4), %r9d
cmpl $-0x1, %r9d
je 0x204d3e
incl %r9d
movl %r9d, (%r8,%rcx,4)
leal 0x3(,%rcx,4), %ecx
andl 0x110(%rdi), %ecx
decl %esi
jne 0x204d0a
popq %rax
retq
callq 0x7eeb8
callq 0x7ee7f
callq 0x7eeef
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixer.c
// Function: gt_suffixer_sort_with_dcov
static void gt_suffixer_sort_with_dcov(void *voidsfi,
                                       GtSuffixsortspace *sssp,
                                       GtUword blisbl,
                                       GtUword width,
                                       GtUword depth)
{
  Sfxiterator *sfi = (Sfxiterator *) voidsfi;

  gt_assert(sfi != NULL);
  gt_differencecover_sortunsortedbucket(sssp,
                                        gt_Outlcpinfo_lcpvalues_ref(
                                               sfi->outlcpinfo),
                                        sfi->dcov, blisbl, width,depth);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2052a1
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0xb8(%rdi), %rdi
callq 0x1f682f
movq 0x88(%r13), %rdx
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1f37cf
callq 0x7f3e6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_clone
GtSuffixsortspace *gt_suffixsortspace_clone(GtSuffixsortspace *sssp,
                                            unsigned int clonenumber,
                                            GtLogger *logger)
{
  bool useuint;
  void *tab2clone;
  GtSuffixsortspace *cloned_sssp;

  gt_assert(sssp != NULL);
  useuint = sssp->uinttab != NULL ? true : false;
  tab2clone = useuint ? (void *) sssp->uinttab
                      : (void *) sssp->ulongtab;
  gt_assert(tab2clone != NULL);
  cloned_sssp = gt_suffixsortspace_new_generic(sssp->maxindex + 1,
                                               sssp->maxvalue,
                                               useuint,
                                               tab2clone,
                                               logger);
  gt_assert(clonenumber > 0);
  cloned_sssp->clonenumber = clonenumber;
  cloned_sssp->partoffset = sssp->partoffset;
  return cloned_sssp;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x205e54
movq %rdx, %r8
movl %esi, %ebp
movq %rdi, %rbx
movq 0x58(%rdi), %rax
movq %rax, %rcx
testq %rax, %rax
jne 0x205e21
movq 0x50(%rbx), %rcx
testq %rcx, %rcx
je 0x205e59
xorl %edx, %edx
testq %rax, %rax
setne %dl
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
incq %rdi
callq 0x205c8b
testl %ebp, %ebp
je 0x205e5e
movl %ebp, 0x4(%rax)
movq 0x38(%rbx), %rcx
movq %rcx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x7fb75
callq 0x7fb3c
callq 0x7fb03
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_delete
void gt_suffixsortspace_delete(GtSuffixsortspace *suffixsortspace,
                               bool checklongestdefined)
{
  if (suffixsortspace != NULL)
  {
    if (checklongestdefined && !suffixsortspace->longestidx.defined)
    {
      fprintf(stderr,"%s, l. %d: longest is not defined\n",__FILE__,__LINE__);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    if (suffixsortspace->clonenumber == 0)
    {
      gt_free(suffixsortspace->uinttab);
      gt_free(suffixsortspace->ulongtab);
    }
    gt_free(suffixsortspace);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x205ec4
movq %rdi, %rbx
testb %sil, %sil
je 0x205e7a
cmpb $0x0, 0x8(%rbx)
je 0x205ecc
cmpl $0x0, 0x4(%rbx)
jne 0x205ea9
movq 0x58(%rbx), %rdi
leaq 0x1be73d(%rip), %r14    # 0x3c45c8
movq %r14, %rsi
movl $0xcd, %edx
callq 0x109670
movq 0x50(%rbx), %rdi
movq %r14, %rsi
movl $0xce, %edx
callq 0x109670
leaq 0x1be718(%rip), %rsi    # 0x3c45c8
movq %rbx, %rdi
movl $0xd0, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x7fbae
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_getdirect
GtUword gt_suffixsortspace_getdirect(const GtSuffixsortspace *sssp,GtUword idx)
{
  gt_assert(sssp != NULL && idx <= sssp->maxindex);
  if (sssp->ulongtab != NULL)
  {
    return sssp->ulongtab[idx];
  }
  gt_assert(sssp->uinttab != NULL);
  return (GtUword) sssp->uinttab[idx];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x205f14
cmpq %rsi, 0x28(%rdi)
jb 0x205f14
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x205f06
movq (%rax,%rsi,8), %rax
jmp 0x205f12
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x205f19
movl (%rax,%rsi,4), %eax
popq %rcx
retq
callq 0x7fc4d
callq 0x7fc14
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_showrange
void gt_suffixsortspace_showrange(const GtSuffixsortspace *sssp,
                                  GtUword subbucketleft,
                                  GtUword width)
{
  GtUword idx;

  gt_assert(sssp != NULL);
  printf(GT_WU","GT_WU"=",sssp->bucketleftidx+subbucketleft-sssp->partoffset,
                    sssp->bucketleftidx+subbucketleft+width-1-sssp->partoffset);
  for (idx=sssp->bucketleftidx+subbucketleft-sssp->partoffset;
       idx<sssp->bucketleftidx+subbucketleft+width-sssp->partoffset;
       idx++)
  {
    printf(" "GT_WU, gt_suffixsortspace_getdirect(sssp,idx));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x205fd3
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x40(%rdi), %rax
addq %rsi, %rax
movq 0x38(%rdi), %rdx
movq %rax, %rsi
subq %rdx, %rsi
addq %rbx, %rax
notq %rdx
addq %rax, %rdx
leaq 0x1be7d5(%rip), %rdi    # 0x3c4746
xorl %eax, %eax
callq 0x17070
movq 0x38(%r14), %rax
movq 0x40(%r14), %rcx
leaq (%rcx,%r12), %r15
subq %rax, %r15
addq %r12, %rbx
addq %rbx, %rcx
subq %rax, %rcx
cmpq %rcx, %r15
jae 0x205fc7
leaq 0x1b3ae7(%rip), %r12    # 0x3b9a83
movq %r14, %rdi
movq %r15, %rsi
callq 0x205eeb
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
incq %r15
movq 0x40(%r14), %rax
addq %rbx, %rax
subq 0x38(%r14), %rax
cmpq %rax, %r15
jb 0x205f9c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x7fcbf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_exportptr
GtSuffixsortspace_exportptr *gt_suffixsortspace_exportptr(
                                  GtSuffixsortspace *sssp,
                                  GtUword subbucketleft)
{
  gt_assert(sssp != NULL);
  if (sssp->ulongtab != NULL)
  {
    sssp->exportptr.ulongtabsectionptr = sssp->ulongtab + sssp->bucketleftidx
                                                        + subbucketleft
                                                        - sssp->partoffset;
    sssp->exportptr.uinttabsectionptr = NULL;
  } else
  {
    gt_assert(sssp->uinttab != NULL);
    sssp->exportptr.uinttabsectionptr = sssp->uinttab + sssp->bucketleftidx
                                                      + subbucketleft
                                                      - sssp->partoffset;
    sssp->exportptr.ulongtabsectionptr = NULL;
  }
  sssp->currentexport = true;
  return &sssp->exportptr;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x206043
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x206008
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,8), %rax
leaq (%rax,%rsi,8), %rdx
shlq $0x3, %rcx
subq %rcx, %rdx
leaq 0x18(%rdi), %rax
movq %rdx, 0x20(%rdi)
jmp 0x206030
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x206048
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
leaq (%rax,%rdx,4), %rax
leaq (%rax,%rsi,4), %rax
shlq $0x2, %rcx
subq %rcx, %rax
movq %rax, 0x18(%rdi)
leaq 0x20(%rdi), %rax
movq $0x0, (%rax)
movb $0x1, (%rdi)
addq $0x18, %rdi
movq %rdi, %rax
popq %rcx
retq
callq 0x7fd31
callq 0x7fcf8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_export_done
void gt_suffixsortspace_export_done (GtSuffixsortspace *sssp)
{
  gt_assert(sssp != NULL);
  sssp->exportptr.ulongtabsectionptr = NULL;
  sssp->exportptr.uinttabsectionptr = NULL;
  sssp->currentexport = false;
}

// Assembly:
testq %rdi, %rdi
je 0x20605d
movb $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
retq
pushq %rax
callq 0x7fd6a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/sfx-suffixgetset.c
// Function: gt_suffixsortspace_get
GtUword gt_suffixsortspace_get (const GtSuffixsortspace *sssp,
                                GtUword subbucketleft,
                                GtUword idx)
{
  gt_assert(sssp != NULL);
  return gt_suffixsortspace_getdirect(sssp, sssp->bucketleftidx
                                              + subbucketleft
                                              + idx
                                              - sssp->partoffset);
}

// Assembly:
testq %rdi, %rdi
je 0x20607b
addq %rsi, %rdx
addq 0x40(%rdi), %rdx
subq 0x38(%rdi), %rdx
movq %rdx, %rsi
jmp 0x205eeb
pushq %rax
callq 0x7fda3