LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x1a4e58
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x54(%rdi)
jne 0x1a4df2
movq 0x20(%rbx), %rdi
leaq 0x1b4710(%rip), %rsi    # 0x3594f8
movl $0x11d, %edx            # imm = 0x11D
callq 0x936f9
cmpb $0x0, 0x55(%rbx)
jne 0x1a4e0d
movq 0x18(%rbx), %rdi
leaq 0x1b46f5(%rip), %rsi    # 0x3594f8
movl $0x121, %edx            # imm = 0x121
callq 0x936f9
cmpb $0x0, 0x56(%rbx)
jne 0x1a4e28
movq 0x30(%rbx), %rdi
leaq 0x1b46da(%rip), %rsi    # 0x3594f8
movl $0x125, %edx            # imm = 0x125
callq 0x936f9
cmpl $0x1, 0x50(%rbx)
je 0x1a4e43
movq 0x28(%rbx), %rdi
leaq 0x1b46bf(%rip), %rsi    # 0x3594f8
movl $0x129, %edx            # imm = 0x129
callq 0x936f9
leaq 0x1b46ae(%rip), %rsi    # 0x3594f8
movq %rbx, %rdi
movl $0x12b, %edx            # imm = 0x12B
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b452c(%rip), %rbx    # 0x3594f8
pushq $0x4
popq %rsi
movq %r12, %rdi
movq %rbx, %rdx
movl $0x67e, %ecx            # imm = 0x67E
callq 0x9334a
movq %rax, %r15
pushq $0x58
popq %rdi
movq %rbx, %rsi
movl $0x93, %edx
callq 0x93160
movq %rax, %rbx
andl $0x0, 0x50(%rax)
movq %r13, 0x38(%rax)
movq %r14, (%rax)
movq $0x100, 0x8(%rax)       # imm = 0x100
andq $0x0, 0x48(%rax)
andl $0x0, 0x40(%rax)
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1a5332
movq 0x38(%rbx), %rcx
movq %rcx, %rax
addq %r14, %rcx
cmpq %rcx, %rax
jae 0x1a5041
movq 0x18(%rbx), %rcx
movzbl (%rax), %edx
incl (%rcx,%rdx,4)
incq %rax
movq 0x38(%rbx), %rcx
jmp 0x1a5026
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 0x1a2937
addq $0x20, %rsp
movq %rbx, %rdi
callq 0x1a4dca
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_O2/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 0x1a5266
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x13371c
movq (%rbx), %rdi
leaq 0x1b42c7(%rip), %r14    # 0x3594f8
movq %r14, %rsi
movl $0x6ef, %edx            # imm = 0x6EF
callq 0x936f9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x6f0, %edx            # imm = 0x6F0
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x6f1, %edx            # imm = 0x6F1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a5296
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x133da4
movq %rax, %r14
movq 0x10(%rbx), %rdi
callq 0x133e7b
subq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x292ccb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13fd6c(%rip), %rsi    # 0x2e5013
leaq 0x19f656(%rip), %rdx    # 0x344904
leaq 0x1b42f8(%rip), %rcx    # 0x3595ad
leaq 0x1b423c(%rip), %r8     # 0x3594f8
movl $0x6fa, %r9d            # imm = 0x6FA
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1a52f9
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
movq 0x292c67(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13fd08(%rip), %rsi    # 0x2e5013
leaq 0x19f5f2(%rip), %rdx    # 0x344904
leaq 0x1b42b9(%rip), %rcx    # 0x3595d2
leaq 0x1b41d8(%rip), %r8     # 0x3594f8
movl $0x70a, %r9d            # imm = 0x70A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1b41aa(%rip), %r12    # 0x3594f8
pushq $0x4
popq %rsi
pushq $0x5a
popq %rcx
movq %r12, %rdx
callq 0x9334a
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rdi
shlq $0x2, %rdi
pushq $0x5d
popq %rdx
movq %r12, %rsi
callq 0x93160
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 0x1a53bb
shlq $0x3, %rdi
leaq 0x1b414b(%rip), %rsi    # 0x3594f8
pushq $0x62
popq %rdx
callq 0x93160
movq 0x8(%rbx), %rdi
jmp 0x1a53bd
xorl %eax, %eax
movq %rax, 0x30(%rbx)
leaq 0x1b4130(%rip), %rdx    # 0x3594f8
pushq $0x4
popq %rsi
pushq $0x6a
popq %rcx
callq 0x9334a
movq %rax, 0x28(%rbx)
andw $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_O2/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 0x20(%rdi), %rax
andl $0x0, (%rax)
movq 0x8(%rdi), %rcx
xorl %edx, %edx
pushq $0x1
popq %rsi
cmpq %rcx, %rsi
jae 0x1a5412
movq 0x18(%rdi), %r8
addl -0x4(%r8,%rsi,4), %edx
movl %edx, (%rax,%rsi,4)
incq %rsi
jmp 0x1a53fc
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movl (%rax), %edx
movl %edx, (%rcx)
movq 0x8(%rdi), %rsi
pushq $0x1
popq %rdi
cmpq %rsi, %rdi
jae 0x1a5436
addl (%rax,%rdi,4), %edx
movl %edx, (%rcx,%rdi,4)
incq %rdi
jmp 0x1a5426
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
movl (%rsi,%rax,4), %ecx
testl %ecx, %ecx
jns 0x1a547c
notl %ecx
movl %ecx, (%rsi,%rax,4)
incq %rax
cmpq %rdx, %rax
jb 0x1a543a
movq 0x292b13(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13fbb4(%rip), %rsi    # 0x2e5013
leaq 0x1b489f(%rip), %rdx    # 0x359d05
leaq 0x1b48ba(%rip), %rcx    # 0x359d27
leaq 0x1b4084(%rip), %r8     # 0x3594f8
movl $0x32a, %r9d            # imm = 0x32A
jmp 0x1a54ef
cmpq %rdi, %rax
jae 0x1a54bf
movq %rax, %rcx
leaq 0x1(%rax), %r8
cmpq %rdx, %r8
jae 0x1a54c3
movl 0x4(%rsi,%rax,4), %r9d
testl %r9d, %r9d
js 0x1a54a1
andl $0x0, 0x4(%rsi,%rax,4)
movq %r8, %rax
jmp 0x1a5484
cmpq %rax, %rcx
ja 0x1a54fb
notl %r9d
movl %r9d, (%rsi,%rcx,4)
andl $0x0, 0x4(%rsi,%rax,4)
incq %rcx
incq %rax
cmpq %rdi, %rcx
jne 0x1a5484
jmp 0x1a54c1
jne 0x1a5529
popq %rax
retq
movq 0x292a9e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13fb3f(%rip), %rsi    # 0x2e5013
leaq 0x1b4864(%rip), %rdx    # 0x359d3f
leaq 0x1b4845(%rip), %rcx    # 0x359d27
leaq 0x1b400f(%rip), %r8     # 0x3594f8
movl $0x330, %r9d            # imm = 0x330
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x292a66(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13fb07(%rip), %rsi    # 0x2e5013
leaq 0x1b4848(%rip), %rdx    # 0x359d5b
leaq 0x1b480d(%rip), %rcx    # 0x359d27
leaq 0x1b3fd7(%rip), %r8     # 0x3594f8
movl $0x334, %r9d            # imm = 0x334
jmp 0x1a54ef
movq 0x292a38(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13fad9(%rip), %rsi    # 0x2e5013
leaq 0x1b482d(%rip), %rdx    # 0x359d6e
leaq 0x1b47df(%rip), %rcx    # 0x359d27
leaq 0x1b3fa9(%rip), %r8     # 0x3594f8
movl $0x344, %r9d            # imm = 0x344
jmp 0x1a54ef
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %r15
movq %rdi, %r12
movq %rdx, 0x8(%rsp)
leaq 0x1(%rdx), %rax
movq %rax, 0x10(%rsp)
pushq $0x1
popq %r14
cmpq 0x10(%rsp), %r14
je 0x1a5968
movl -0x4(%r15,%r14,4), %r13d
movl (%r15,%r14,4), %ebp
cmpl %ebp, %r13d
je 0x1a59f4
movq (%r12), %rax
cmpq %r13, %rax
jb 0x1a59f4
cmpq %rbp, %rax
jb 0x1a59f4
cmpq %rax, %r13
je 0x1a5977
cmpq %rax, %rbp
je 0x1a595a
movq %r12, %rdi
movq %r13, %rsi
callq 0x1a7485
movq %rax, %rbx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1a7485
cmpq %rax, %rbx
jb 0x1a5963
ja 0x1a597c
incq %r13
incq %rbp
movq (%r12), %rax
jmp 0x1a5924
cmpq %rax, %r13
jae 0x1a5a22
incq %r14
jmp 0x1a58f5
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq %rbp, %rax
jbe 0x1a59bc
movq 0x2925e5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
movl -0x4(%r15,%r14,4), %r10d
movl (%r15,%r14,4), %r11d
leaq 0x1b4761(%rip), %rsi    # 0x35a0f7
leaq 0x1b4796(%rip), %rdx    # 0x35a133
xorl %ecx, %ecx
movq 0x8(%rsp), %r8
movq %r14, %r9
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x17a50
popq %rcx
popq %rdx
pushq $0x2
popq %rdi
callq 0x178f0
movq 0x2925a5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13f646(%rip), %rsi    # 0x2e5013
leaq 0x1b44f9(%rip), %rdx    # 0x359ecd
leaq 0x1b476b(%rip), %rcx    # 0x35a146
leaq 0x1b3b16(%rip), %r8     # 0x3594f8
movl $0x3dd, %r9d            # imm = 0x3DD
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x29256d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13f60e(%rip), %rsi    # 0x2e5013
leaq 0x1b4446(%rip), %rdx    # 0x359e52
leaq 0x1b4733(%rip), %rcx    # 0x35a146
leaq 0x1b3ade(%rip), %r8     # 0x3594f8
movl $0x3d5, %r9d            # imm = 0x3D5
jmp 0x1a59e8
movq 0x29253f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13f5e0(%rip), %rsi    # 0x2e5013
leaq 0x1b44a3(%rip), %rdx    # 0x359edd
leaq 0x1b4705(%rip), %rcx    # 0x35a146
leaq 0x1b3ab0(%rip), %r8     # 0x3594f8
movl $0x3e2, %r9d            # imm = 0x3E2
jmp 0x1a59e8
// File: /workspace/github_c_makefile_star2_O2/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 0x1a5f6d
incl %r9d
movw %r9w, (%rax,%rsi,2)
retq
movq 0x20(%rdi), %rdx
movq 0x28(%rdi), %r9
movl (%rdx,%rsi,4), %r10d
leaq (%r8,%rcx,4), %rdi
leaq (%r9,%r10,4), %r9
addq $-0x4, %r9
cmpq %rdi, %r8
jae 0x1a5f9a
movl (%r8), %r10d
addq $0x4, %r8
movl %r10d, (%r9)
addq $-0x4, %r9
jmp 0x1a5f85
andw $0x0, (%rax,%rsi,2)
subl %ecx, (%rdx,%rsi,4)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a6012
pushq %rbx
movq 0x8(%rdi), %rax
xorl %edx, %edx
cmpq %rax, %rdx
je 0x1a6011
movq 0x30(%rdi), %rsi
movzwl (%rsi,%rdx,2), %r8d
testl %r8d, %r8d
je 0x1a600c
movq 0x20(%rdi), %r9
movb 0x38(%rdi), %cl
movq %rdx, %r10
shlq %cl, %r10
movq 0x28(%rdi), %r11
shlq $0x2, %r10
addq 0x18(%rdi), %r10
movl (%r9,%rdx,4), %ebx
movl %r8d, %ecx
leaq (%r10,%rcx,4), %rcx
leaq (%r11,%rbx,4), %r11
addq $-0x4, %r11
cmpq %rcx, %r10
jae 0x1a6003
movl (%r10), %ebx
addq $0x4, %r10
movl %ebx, (%r11)
addq $-0x4, %r11
jmp 0x1a5fee
andw $0x0, (%rsi,%rdx,2)
subl %r8d, (%r9,%rdx,4)
incq %rdx
jmp 0x1a5faf
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a605f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x1b34ce(%rip), %r14    # 0x3594f8
movq %r14, %rsi
movl $0x1d6, %edx            # imm = 0x1D6
callq 0x936f9
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x1d7, %edx            # imm = 0x1D7
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1d8, %edx            # imm = 0x1D8
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1a7485
cmpq 0x8(%r12), %rax
jae 0x1a7279
movq %rax, %r15
movq 0x20(%r12), %rax
movl (%rax,%r15,4), %ebp
decl %ebp
movl %ebp, (%rax,%r15,4)
testl %r14d, %r14d
jle 0x1a7282
decl %r14d
movq %r12, %rdi
movq %r14, %rsi
callq 0x1a7485
movq 0x30(%r12), %rcx
testq %rcx, %rcx
je 0x1a7267
xorl %edx, %edx
cmpq %r15, %rax
seta %dl
leaq (%rdx,%r15,2), %rdx
movl 0x10(%r12), %esi
cmpl %esi, (%rcx,%rdx,4)
ja 0x1a72b0
jae 0x1a7263
movl %esi, (%rcx,%rdx,4)
addl (%r12), %r14d
pushq $-0x2
popq %rcx
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
movq 0x290cdf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13dd80(%rip), %rsi    # 0x2e5013
leaq 0x1b28c9(%rip), %rdx    # 0x359b63
leaq 0x1b28cf(%rip), %rcx    # 0x359b70
leaq 0x1b2250(%rip), %r8     # 0x3594f8
movl $0x1f4, %r9d            # imm = 0x1F4
jmp 0x1a72dc
movq 0x290cb1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13dd52(%rip), %rsi    # 0x2e5013
leaq 0x1b277c(%rip), %rdx    # 0x359a44
leaq 0x1b28a1(%rip), %rcx    # 0x359b70
leaq 0x1b2222(%rip), %r8     # 0x3594f8
movl $0x1fb, %r9d            # imm = 0x1FB
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1a7500
movl 0x50(%rdi), %eax
cmpq $0x3, %rax
ja 0x1a74fc
movq %rsi, %rbx
leaq 0x1b204a(%rip), %rcx    # 0x3594e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x38(%rdi), %rax
movzbl (%rax,%rbx), %eax
jmp 0x1a74fe
movq 0x38(%rdi), %rax
movl 0x40(%rdi), %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x705e4
addq $0x100, %rbx            # imm = 0x100
cmpb $-0x2, %al
movzbl %al, %eax
cmovaeq %rbx, %rax
jmp 0x1a74fe
movq 0x38(%rdi), %rax
movzbl (%rax,%rbx), %eax
addq $0x100, %rbx            # imm = 0x100
cmpq $0xfe, %rax
cmovbq %rax, %rbx
movq %rbx, %rax
jmp 0x1a74fe
movq 0x38(%rdi), %rax
movl (%rax,%rbx,4), %eax
jmp 0x1a74fe
xorl %eax, %eax
popq %rbx
retq
movq 0x290a61(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13db02(%rip), %rsi    # 0x2e5013
leaq 0x1b267a(%rip), %rdx    # 0x359b92
leaq 0x1b2693(%rip), %rcx    # 0x359bb2
leaq 0x1b1fd2(%rip), %r8     # 0x3594f8
movl $0x136, %r9d            # imm = 0x136
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1a7485
cmpq 0x8(%r15), %rax
jae 0x1a75a0
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 0x1a75af
testl %ebp, %ebp
je 0x1a7593
leal -0x2(%r14), %eax
movslq %eax, %rsi
movq %r15, %rdi
callq 0x1a7485
cmpq %r12, %rax
jbe 0x1a7599
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
movq 0x2909b2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13da53(%rip), %rsi    # 0x2e5013
leaq 0x1b2d02(%rip), %rdx    # 0x35a2c9
leaq 0x1b2d20(%rip), %rcx    # 0x35a2ee
leaq 0x1b1f23(%rip), %r8     # 0x3594f8
movl $0x252, %r9d            # imm = 0x252
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1a7796
movsd 0x1b2c64(%rip), %xmm0   # 0x35a3f8
jmp 0x1a779e
movsd 0x1b2c52(%rip), %xmm0   # 0x35a3f0
movsd 0x13ea82(%rip), %xmm1   # 0x2e6228
cmpq $0x41, %rdx
jb 0x1a77b9
shrq $0x6, %rdx
cvtsi2sd %rdx, %xmm2
addsd %xmm2, %xmm1
mulsd 0x1748ff(%rip), %xmm1   # 0x31c0c0
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x140547(%rip), %xmm1   # 0x2e7d20
cvttsd2si %xmm1, %rax
andq %rdx, %rax
orq %rcx, %rax
imulq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2b92(%rip), %rsi    # 0x35a400
pushq $0x58
popq %rdi
movl $0x8e, %edx
callq 0x93160
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)
andq $0x0, 0x10(%r15)
movups %xmm0, 0x40(%r15)
movb %r12b, 0x52(%r15)
movups %xmm0, 0x18(%r15)
movups %xmm0, 0x28(%r15)
testq %r14, %r14
je 0x1a78cf
movzbl %bpl, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1a78e1
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_O2/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 0x1a7b08
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x1b297a(%rip), %r14    # 0x35a400
movq %r14, %rsi
movl $0xa9, %edx
callq 0x936f9
andq $0x0, (%rbx)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0xab, %edx
callq 0x936f9
andq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0xad, %edx
callq 0x936f9
andq $0x0, 0x18(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1a7aed
leaq 0x20(%rbx), %r14
leaq 0x1b2929(%rip), %rsi    # 0x35a400
movl $0xaf, %edx
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x1b290c(%rip), %rsi    # 0x35a400
movq %rbx, %rdi
movl $0xb0, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/spmsuftab.h
// Function: gt_spmsuftab_get
GT_UNUSED static inline GtUword gt_spmsuftab_get(
                                      const GtSpmsuftab *spmsuftab,
                                      GtUword idx)
{
  gt_assert(idx >= spmsuftab->partoffset);
  idx -= spmsuftab->partoffset;
  gt_assert(idx < spmsuftab->numofentries);
  return gt_compact_ulong_store_get(spmsuftab->bitpackarray,idx);
}

// Assembly:
pushq %rax
subq (%rdi), %rsi
jb 0x1a8d0b
cmpq 0x8(%rdi), %rsi
jae 0x1a8d35
movq 0x20(%rdi), %rdi
popq %rax
jmp 0x6bb8d
movq 0x28f256(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13c2f7(%rip), %rsi    # 0x2e5013
leaq 0x19d7f6(%rip), %rdx    # 0x346519
leaq 0x1a404c(%rip), %rcx    # 0x34cd76
leaq 0x1a3e1b(%rip), %r8     # 0x34cb4c
pushq $0x2f
jmp 0x1a8d5d
movq 0x28f22c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13c2cd(%rip), %rsi    # 0x2e5013
leaq 0x1a403a(%rip), %rdx    # 0x34cd87
leaq 0x1a4022(%rip), %rcx    # 0x34cd76
leaq 0x1a3df1(%rip), %r8     # 0x34cb4c
pushq $0x31
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/sfx-shortreadsort.c
// Function: shortread_gt_inlined_qsort_arr_r_med3
static inline GtUword QSORTNAME(gt_inlined_qsort_arr_r_med3)
                     (GtUword a, GtUword b, GtUword c,
                      QSORTNAME(Datatype) data)
{
  return QSORTNAME(qsortcmparr) (a, b, data) < 0
           ? (QSORTNAME(qsortcmparr) (b, c, data) < 0
                ? b
                : (QSORTNAME(qsortcmparr) (a, c, data) < 0 ? c : a))
           : (QSORTNAME(qsortcmparr) (b, c, data) > 0
                ? b
                : (QSORTNAME(qsortcmparr) (a, c, data) < 0 ? a : c));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rcx, %rdx
callq 0x1a8d6b
movl %eax, %ebp
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1a8d6b
testl %ebp, %ebp
js 0x1a8f66
testl %eax, %eax
jg 0x1a8f81
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1a8d6b
testl %eax, %eax
cmovsq %r14, %rbx
movq %rbx, %r12
jmp 0x1a8f81
testl %eax, %eax
js 0x1a8f81
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1a8d6b
testl %eax, %eax
cmovsq %rbx, %r14
movq %r14, %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
xorl %ecx, %ecx
callq 0x19f20f
movq %rax, %r14
movq %rax, %rdi
callq 0x19f955
testb %al, %al
je 0x1a9124
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x19f495
testq %rax, %rax
je 0x1a914b
leaq 0x1(%r15), %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1a915e
movq %r12, %r15
jmp 0x1a9127
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x19f83e
// File: /workspace/github_c_makefile_star2_O2/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 0x1ab387
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 0x1ab35b
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 0x1ab37f
retq
orq %r8, %rsi
movq %rsi, (%rdx,%rdi,8)
retq
pushq %rax
movq 0x28cbd9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x139c7a(%rip), %rsi    # 0x2e5013
leaq 0x1af9e1(%rip), %rdx    # 0x35ad81
leaq 0x1af9e7(%rip), %rcx    # 0x35ad8e
leaq 0x1af2ce(%rip), %r8     # 0x35a67c
movl $0x4a8, %r9d            # imm = 0x4A8
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1ac04c
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1ac0be
testq %r15, %r15
je 0x1ac090
cmpq $0x0, 0x78(%r15)
je 0x1ac090
movq 0x68(%r15), %rdi
callq 0x1a137a
cmpl $0x1, %eax
ja 0x1ac083
movq 0x78(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x134a7b
movl %eax, %ebp
movq %rbx, %rdi
callq 0x8a4fd
movl %ebp, %eax
jmp 0x1ac085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28bed1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x138f72(%rip), %rsi    # 0x2e5013
leaq 0x1aeab4(%rip), %rdx    # 0x35ab5c
leaq 0x1aea92(%rip), %rcx    # 0x35ab41
leaq 0x1ae5c6(%rip), %r8     # 0x35a67c
movl $0x8a1, %r9d            # imm = 0x8A1
jmp 0x1ac0ea
movq 0x28bea3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x138f44(%rip), %rsi    # 0x2e5013
leaq 0x1390e9(%rip), %rdx    # 0x2e51bf
leaq 0x1aea64(%rip), %rcx    # 0x35ab41
leaq 0x1ae598(%rip), %r8     # 0x35a67c
movl $0x8a0, %r9d            # imm = 0x8A0
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1ac110
cmpl $0x0, 0x50(%rdi)
je 0x1ac104
xorl %eax, %eax
retq
movq 0x90(%rdi), %rdi
jmp 0x1afe7b
pushq %rax
movq 0x28be50(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x138ef1(%rip), %rsi    # 0x2e5013
leaq 0x168b46(%rip), %rdx    # 0x314c6f
leaq 0x1aea4f(%rip), %rcx    # 0x35ab7f
leaq 0x1ae545(%rip), %r8     # 0x35a67c
movl $0x8ad, %r9d            # imm = 0x8AD
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1ac244
andq 0x140(%rdi), %rsi
cmpq 0x150(%rdi), %rsi
jae 0x1ac272
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 0x1ac240
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 0x1ac242
xorl %eax, %eax
popq %rcx
retq
movq 0x28bd1d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x138dbe(%rip), %rsi    # 0x2e5013
leaq 0x1ae9c0(%rip), %rdx    # 0x35ac1c
leaq 0x1ae9e6(%rip), %rcx    # 0x35ac49
leaq 0x1ae412(%rip), %r8     # 0x35a67c
movl $0x163, %r9d            # imm = 0x163
jmp 0x1ac29e
movq 0x28bcef(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x138d90(%rip), %rsi    # 0x2e5013
leaq 0x1ae9db(%rip), %rdx    # 0x35ac65
leaq 0x1ae9b8(%rip), %rcx    # 0x35ac49
leaq 0x1ae3e4(%rip), %r8     # 0x35a67c
movl $0x164, %r9d            # imm = 0x164
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/kmercodes.h
// Function: gt_kmercode_at_position
static inline GtCodetype gt_kmercode_at_position(
                                   const GtTwobitencoding *twobitencoding,
                                   GtUword pos,
                                   unsigned int kmersize)
{
  const unsigned int unitoffset = (unsigned int) GT_MODBYUNITSIN2BITENC(pos);
  const GtUword unitindex = GT_DIVBYUNITSIN2BITENC(pos);
  const GtCodetype maskright = GT_MASKRIGHT(kmersize);

  if (unitoffset <= (unsigned int) GT_UNITSIN2BITENC - kmersize)
  {
    return (GtCodetype) (twobitencoding[unitindex]
            >> GT_MULT2(GT_UNITSIN2BITENC - kmersize - unitoffset))
           & maskright;
  } else
  {
    unsigned int shiftleft = GT_MULT2(unitoffset+kmersize-GT_UNITSIN2BITENC);
    return (GtCodetype)
           ((twobitencoding[unitindex] << shiftleft) |
            (twobitencoding[unitindex+1] >> (GT_MULT2(GT_UNITSIN2BITENC) -
                                             shiftleft)))
           & maskright;
  }
}

// Assembly:
movl %esi, %ecx
andl $0x1f, %ecx
shrq $0x5, %rsi
pushq $0x20
popq %r8
subl %edx, %r8d
movl %r8d, %r9d
subl %ecx, %r9d
jae 0x1ac2d8
addl %edx, %ecx
addl %ecx, %ecx
addb $-0x40, %cl
movq (%rdi,%rsi,8), %rax
movq 0x8(%rdi,%rsi,8), %rdx
shldq %cl, %rdx, %rax
jmp 0x1ac2e5
movq (%rdi,%rsi,8), %rax
addl %r9d, %r9d
movl %r9d, %ecx
shrq %cl, %rax
addl %r8d, %r8d
movl %r8d, %ecx
shlq %cl, %rax
shrq %cl, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x50(%rdi)
jne 0x1ae2f8
movl %ecx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpb $0x1, 0x55(%rdi)
jne 0x1ae2ee
movq 0x100(%r14), %rax
movq 0x108(%r14), %rcx
leaq 0x1(%rax), %rsi
movq %rsi, 0x100(%r14)
shlq $0x4, %rax
movl %ebp, %esi
andl $0xf, %esi
movl %ebx, %edi
shll $0x4, %edi
orl %esi, %edi
movl %edi, (%rcx,%rax)
movq %rdx, 0x8(%rcx,%rax)
jmp 0x1ae2ee
movq 0x80(%r14), %rdi
movl %ebx, %esi
callq 0x1ae378
leal 0x3(,%rbx,4), %ebx
andl 0x110(%r14), %ebx
subl $0x1, %ebp
jae 0x1ae2d2
popq %rbx
popq %r14
popq %rbp
retq
movq 0x289c69(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x136d0a(%rip), %rsi    # 0x2e5013
leaq 0x1acbed(%rip), %rdx    # 0x35aefd
leaq 0x1acc28(%rip), %rcx    # 0x35af3f
leaq 0x1ac35e(%rip), %r8     # 0x35a67c
movl $0x440, %r9d            # imm = 0x440
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/bcktab.h
// Function: gt_bcktab_leftborder_addcode
static inline void gt_bcktab_leftborder_addcode(GtLeftborder *lb,
                                                             GtCodetype code)
{
  gt_assert(lb != NULL);
  if (lb->ulongbounds != NULL)
  {
    lb->ulongbounds[code]++;
  } else
  {
    gt_assert(lb->uintbounds[code] < (uint32_t) UINT_MAX);
    lb->uintbounds[code]++;
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1ae39f
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1ae38d
incq (%rax,%rsi,8)
jmp 0x1ae39d
movq (%rdi), %rax
movl (%rax,%rsi,4), %ecx
cmpl $-0x1, %ecx
je 0x1ae3c9
incl %ecx
movl %ecx, (%rax,%rsi,4)
popq %rax
retq
movq 0x289bc2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x136c63(%rip), %rsi    # 0x2e5013
leaq 0x1902a8(%rip), %rdx    # 0x33e65f
leaq 0x1a8fe1(%rip), %rcx    # 0x35739f
leaq 0x1a8ff7(%rip), %r8     # 0x3573bc
pushq $0x36
jmp 0x1ae3f1
movq 0x289b98(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x136c39(%rip), %rsi    # 0x2e5013
leaq 0x1a8fee(%rip), %rdx    # 0x3573cf
leaq 0x1a8fb7(%rip), %rcx    # 0x35739f
leaq 0x1a8fcd(%rip), %r8     # 0x3573bc
pushq $0x3c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1ae9ab
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0xb8(%rdi), %rdi
callq 0x19d7ea
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 0x19a18a
movq 0x2895b6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x136657(%rip), %rsi    # 0x2e5013
leaq 0x1662ac(%rip), %rdx    # 0x314c6f
leaq 0x1ac9d3(%rip), %rcx    # 0x35b39d
leaq 0x1abcab(%rip), %r8     # 0x35a67c
movl $0x794, %r9d            # imm = 0x794
xorl %eax, %eax
callq 0x17a50
callq 0x17390