LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_Sfxmappedrange_usetmp
void gt_Sfxmappedrange_usetmp(GtSfxmappedrange *sfxmappedrange,
                              const GtStr *tmpfilename,
                              void **usedptrptr,
                              GtUword numofentries,
                              bool writable)
{
  gt_assert(sfxmappedrange != NULL);
  sfxmappedrange->ptr = NULL;
  /*gt_assert(usedptrptr != NULL && *usedptrptr == NULL);*/
  sfxmappedrange->usedptrptr = usedptrptr;
  sfxmappedrange->filename = gt_str_clone(tmpfilename);
  sfxmappedrange->writable = writable;
  if (sfxmappedrange->type == GtSfxGtBitsequence)
  {
    sfxmappedrange->numofunits = GT_NUMOFINTSFORBITS(numofentries);
  } else
  {
    sfxmappedrange->numofunits = (size_t) numofentries;
  }
  gt_log_log("use file %s for table %s ("GT_WU" units of "GT_WU" bytes)",
             gt_str_get(sfxmappedrange->filename),
             gt_str_get(sfxmappedrange->tablename),
             (GtUword) sfxmappedrange->numofunits,
             (GtUword) sfxmappedrange->sizeofunit);
  gt_free(*sfxmappedrange->usedptrptr);
  *sfxmappedrange->usedptrptr = NULL;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x2cc1f1
movq 0x36fde0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x249e49(%rip), %rsi    # 0x516013
leaq 0x2bf1ad(%rip), %rdx    # 0x58b37e
leaq 0x2bf303(%rip), %rcx    # 0x58b4db
leaq 0x2bf1d4(%rip), %r8     # 0x58b3b3
movl $0xf3, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2cc1f3
movq 0x30(%rsp), %rax
movq $0x0, (%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rdi
callq 0x11e280
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movb 0x17(%rsp), %cl
movq 0x30(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x70(%rax)
movq 0x30(%rsp), %rax
cmpl $0x0, 0x40(%rax)
jne 0x2cc27e
movq 0x18(%rsp), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
jne 0x2cc258
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x2cc26e
movq 0x18(%rsp), %rax
subq $0x1, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x2cc28c
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11dee0
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dee0
movq (%rsp), %rsi
movq %rax, %rdx
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x38(%rax), %r8
leaq 0x2bf228(%rip), %rdi    # 0x58b4f4
movb $0x0, %al
callq 0xe7740
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
leaq 0x2bf0cd(%rip), %rsi    # 0x58b3b3
movl $0x105, %edx            # imm = 0x105
callq 0xe88c0
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_Sfxmappedrange_size_mapped
GtUword gt_Sfxmappedrange_size_mapped(const GtSfxmappedrange
                                                      *sfxmappedrange,
                                            GtUword minindex,
                                            GtUword maxindex)
{
  gt_assert(sfxmappedrange != NULL);
  if (sfxmappedrange->transformfunc != NULL)
  {
    sfxmappedrange->transformfunc(&minindex,&maxindex,
                                  sfxmappedrange->transformfunc_data);
  }
  if (minindex <= maxindex)
  {
    GtMappedrange lbrange;

    gt_Sfxmapped_offset_end(&lbrange,
                            sfxmappedrange->sizeofunit,
                            sfxmappedrange->pagesize,
                            minindex,
                            maxindex);
    return lbrange.mapend - lbrange.mapoffset + 1;
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2cc363
movq 0x36fc6e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x249cd7(%rip), %rsi    # 0x516013
leaq 0x2bf03b(%rip), %rdx    # 0x58b37e
leaq 0x2bf1dc(%rip), %rcx    # 0x58b526
leaq 0x2bf062(%rip), %r8     # 0x58b3b3
movl $0x10e, %r9d            # imm = 0x10E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2cc365
movq 0x28(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x2cc38f
movq 0x28(%rsp), %rax
movq 0x60(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x68(%rcx), %rdx
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq *%rax
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x2cc3d6
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
leaq 0x8(%rsp), %rdi
callq 0x2cc3f0
movq 0x10(%rsp), %rax
subq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2cc3df
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_Sfxmappedrange_unmap
void gt_Sfxmappedrange_unmap(GtSfxmappedrange *sfxmappedrange)
{
  gt_assert(sfxmappedrange != NULL);
  if (sfxmappedrange->ptr != NULL)
  {
    gt_fa_xmunmap(sfxmappedrange->ptr);
  }
  sfxmappedrange->ptr = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2cc4a4
movq 0x36fb2d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x249b96(%rip), %rsi    # 0x516013
leaq 0x2beefa(%rip), %rdx    # 0x58b37e
leaq 0x2bf0b9(%rip), %rcx    # 0x58b544
leaq 0x2bef21(%rip), %r8     # 0x58b3b3
movl $0x124, %r9d            # imm = 0x124
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2cc4a6
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x2cc4bc
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xdb2a0
movq (%rsp), %rax
movq $0x0, (%rax)
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_Sfxmappedrange_delete
void gt_Sfxmappedrange_delete(GtSfxmappedrange *sfxmappedrange)
{
  if (sfxmappedrange == NULL)
  {
    return;
  }
  gt_fa_xmunmap(sfxmappedrange->ptr);
  sfxmappedrange->ptr = NULL;
  gt_fa_xmunmap(sfxmappedrange->entire);
  sfxmappedrange->entire = NULL;
  if (sfxmappedrange->usedptrptr != NULL)
  {
    *sfxmappedrange->usedptrptr = NULL;
  }
  if (sfxmappedrange->filename != NULL)
  {
    gt_xunlink(gt_str_get(sfxmappedrange->filename));
  }
  gt_str_delete(sfxmappedrange->tablename);
  gt_str_delete(sfxmappedrange->filename);
  gt_free(sfxmappedrange);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2cca91
jmp 0x2ccb2a
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xdb2a0
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xdb2a0
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2ccadb
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2ccafb
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11dee0
movq %rax, %rdi
callq 0x127980
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq (%rsp), %rdi
leaq 0x2be893(%rip), %rsi    # 0x58b3b3
movl $0x198, %edx            # imm = 0x198
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_Sfxmappedrangelist_new
GtSfxmappedrangelist *gt_Sfxmappedrangelist_new(void)
{
  GtSfxmappedrangelist *sfxmrlist = gt_malloc(sizeof (*sfxmrlist));

  sfxmrlist->arr = NULL;
  sfxmrlist->nextfree = sfxmrlist->allocated = 0;
  return sfxmrlist;
}

// Assembly:
pushq %rax
movl $0x18, %edi
leaq 0x2be876(%rip), %rsi    # 0x58b3b3
movl $0x1a3, %edx            # imm = 0x1A3
callq 0xe80f0
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_Sfxmappedrangelist_add
void gt_Sfxmappedrangelist_add(GtSfxmappedrangelist *sfxmrlist,
                               GtSfxmappedrange *sfxmappedrange)
{
  gt_assert(sfxmrlist != NULL);

  if (sfxmrlist->nextfree >= sfxmrlist->allocated)
  {
    sfxmrlist->allocated += 4UL;
    sfxmrlist->arr = gt_realloc(sfxmrlist->arr,sizeof (*sfxmrlist->arr) *
                                               sfxmrlist->allocated);
  }
  sfxmrlist->arr[sfxmrlist->nextfree++] = sfxmappedrange;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2ccbce
movq 0x36f403(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x24946c(%rip), %rsi    # 0x516013
leaq 0x2beb23(%rip), %rdx    # 0x58b6d1
leaq 0x2beb2e(%rip), %rcx    # 0x58b6e3
leaq 0x2be7f7(%rip), %r8     # 0x58b3b3
movl $0x1ad, %r9d            # imm = 0x1AD
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ccbd0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2ccc26
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
leaq 0x2be7a2(%rip), %rdx    # 0x58b3b3
movl $0x1b3, %ecx            # imm = 0x1B3
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_Sfxmappedrangelist_size_mapped
GtUword gt_Sfxmappedrangelist_size_mapped(const GtSfxmappedrangelist *sfxmrlist,
                                          GtUword minindex,
                                          GtUword maxindex)
{
  if (sfxmrlist == NULL)
  {
    gt_assert(maxindex >= minindex);
    return maxindex - minindex + 1;
  } else
  {
    GtUword idx, sumsize = 0;

    for (idx = 0; idx < sfxmrlist->nextfree; idx++)
    {
      GtSfxmappedrange *sfxmappedrange = sfxmrlist->arr[idx];
      if (sfxmappedrange != NULL)
      {
        /*printf("size_mapped %s "GT_WU" "GT_WU" => "GT_WU"\n",
                    gt_str_get(sfxmappedrange->tablename),
                    minindex,maxindex,
                    gt_Sfxmappedrange_size_mapped(sfxmappedrange,minindex,
                                                  maxindex));*/
        sumsize += gt_Sfxmappedrange_size_mapped(sfxmappedrange,
                                                 minindex,
                                                 maxindex);
      }
    }
    return sumsize;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x2cccc8
jmp 0x2ccc6d
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2cccb1
movq 0x36f320(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x249389(%rip), %rsi    # 0x516013
leaq 0x2bea6c(%rip), %rdx    # 0x58b6fd
leaq 0x2bea7a(%rip), %rcx    # 0x58b712
leaq 0x2be714(%rip), %r8     # 0x58b3b3
movl $0x1be, %r9d            # imm = 0x1BE
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2cccb3
movq 0x18(%rsp), %rax
subq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2ccd3f
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2ccd35
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2ccd23
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2cc310
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2ccd25
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2cccda
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_Sfxmappedrangelist_size_entire
GtUword gt_Sfxmappedrangelist_size_entire(const GtSfxmappedrangelist *sfxmrlist)
{
  if (sfxmrlist == NULL)
  {
    return 0;
  } else
  {
    GtUword idx, sumsize = 0;

    for (idx = 0; idx < sfxmrlist->nextfree; idx++)
    {
      GtSfxmappedrange *sfxmappedrange = sfxmrlist->arr[idx];
      if (sfxmappedrange != NULL)
      {
        sumsize += gt_Sfxmappedrange_size_entire(sfxmappedrange);
      }
    }
    return sumsize;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2ccd6c
movq $0x0, 0x20(%rsp)
jmp 0x2ccdd9
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2ccdcf
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2ccdbd
movq (%rsp), %rdi
callq 0x2cb990
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2ccdbf
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2ccd7e
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-maprange.c
// Function: gt_multipleofpagesize
static GtUword gt_multipleofpagesize(GtUword code,
                                           bool smaller,
                                           size_t sizeofbasetype,
                                           GtUword pagesize)
{
  if ((code * sizeofbasetype) % pagesize == 0)
  {
    return code * sizeofbasetype;
  }
  if (smaller)
  {
    return ((code * sizeofbasetype)/pagesize) * pagesize;
  }
  return ((code * sizeofbasetype)/pagesize) * pagesize + pagesize;
}

// Assembly:
movb %sil, %al
movq %rdi, -0x10(%rsp)
andb $0x1, %al
movb %al, -0x11(%rsp)
movq %rdx, -0x20(%rsp)
movq %rcx, -0x28(%rsp)
movq -0x10(%rsp), %rax
imulq -0x20(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rsp)
cmpq $0x0, %rdx
jne 0x2cce74
movq -0x10(%rsp), %rax
imulq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x2ccec0
testb $0x1, -0x11(%rsp)
je 0x2cce9c
movq -0x10(%rsp), %rax
imulq -0x20(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rsp)
imulq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x2ccec0
movq -0x10(%rsp), %rax
imulq -0x20(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x28(%rsp)
imulq -0x28(%rsp), %rax
addq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-partssuf.c
// Function: gt_suftabparts_variance
double gt_suftabparts_variance(const GtSuftabparts *suftabparts)
{

  gt_assert(suftabparts->numofparts > 0);
  if (suftabparts->numofparts == 1U)
  {
    return 0.0;
  } else
  {
    double meanwidth, difference, sum = 0.0;
    unsigned int part;

    meanwidth
      = (double)
        gt_suftabparts_sumofwidth(suftabparts->numofparts-1,suftabparts)/
        suftabparts->numofparts;
    for (part = 0; part < suftabparts->numofparts; part++)
    {
      difference = (double) suftabparts->components[part].widthofpart
                   - meanwidth;
      sum += difference * difference;
    }
    return sum/(double) (suftabparts->numofparts-1);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0xc(%rax)
ja 0x2cd37c
movq 0x36ec55(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x248cbe(%rip), %rsi    # 0x516013
leaq 0x2be6de(%rip), %rdx    # 0x58ba3a
leaq 0x2be61f(%rip), %rcx    # 0x58b982
leaq 0x2be430(%rip), %r8     # 0x58b79a
movl $0x160, %r9d            # imm = 0x160
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2cd37e
movq 0x28(%rsp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x2cd397
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x2cd499
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rsi
movl 0xc(%rsi), %edi
decl %edi
callq 0x2cd180
movq %rax, %xmm0
movaps 0x24b575(%rip), %xmm1   # 0x518930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x24b579(%rip), %xmm1   # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x2cd47a
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %xmm0
movaps 0x24b50d(%rip), %xmm1   # 0x518930
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x24b511(%rip), %xmm1   # 0x518940
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
subsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2cd3f5
movsd 0x10(%rsp), %xmm0
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
decl %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-partssuf.c
// Function: gt_suftabparts_minindex_raw
static GtCodetype gt_suftabparts_minindex_raw(unsigned int part,
                                              const GtSuftabparts *suftabparts)
{
  GtCodetype nextidx;

  gt_assert(suftabparts != NULL && part < suftabparts->numofparts);
  nextidx = (part == 0) ? suftabparts->codeoffset
                        : suftabparts->components[part-1].nextidx + 1;
  if (suftabparts->fct != NULL)
  {
    return gt_firstcodes_sample2full(suftabparts->fct,nextidx);
  }
  return nextidx;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2ce043
movl 0x1c(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x2ce07b
movq 0x36df56(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x247fbf(%rip), %rsi    # 0x516013
leaq 0x2bdc30(%rip), %rdx    # 0x58bc8b
leaq 0x2bdc5f(%rip), %rcx    # 0x58bcc1
leaq 0x2bd731(%rip), %r8     # 0x58b79a
movl $0x61, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ce07d
cmpl $0x0, 0x1c(%rsp)
jne 0x2ce093
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
jmp 0x2ce0b7
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x2ce0e6
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x4c0f50
movq %rax, 0x20(%rsp)
jmp 0x2ce0f0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-partssuf.c
// Function: gt_suftabparts_maxindex_raw
static GtCodetype gt_suftabparts_maxindex_raw(unsigned int part,
                                              const GtSuftabparts *suftabparts)
{
  GtCodetype nextidx;

  gt_assert(suftabparts != NULL && suftabparts->components != NULL &&
            part < suftabparts->numofparts);
  nextidx = suftabparts->components[part].nextidx;
  if (suftabparts->fct != NULL)
  {
    return gt_firstcodes_sample2full(suftabparts->fct,nextidx);
  }
  return nextidx;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2ce12e
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2ce12e
movl 0x1c(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x2ce166
movq 0x36de6b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x247ed4(%rip), %rsi    # 0x516013
leaq 0x2bd854(%rip), %rdx    # 0x58b99a
leaq 0x2bdb90(%rip), %rcx    # 0x58bcdd
leaq 0x2bd646(%rip), %r8     # 0x58b79a
movl $0x71, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ce168
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x2ce1aa
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x4c0f50
movq %rax, 0x20(%rsp)
jmp 0x2ce1b4
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-run.c
// Function: gt_parseargsandcallsuffixerator
int gt_parseargsandcallsuffixerator(bool doesa,int argc,
                                    const char **argv,GtError *err)
{
  Suffixeratoroptions so;
  int retval;
  bool haserr = false;

  gt_error_check(err);
  retval = gt_suffixeratoroptions(&so,doesa,argc,argv,err);
  if (retval == 0)
  {
    GtLogger *logger = gt_logger_new(so.beverbose,
                                     GT_LOGGER_DEFLT_PREFIX, stdout);

    gt_logger_log(logger,"sizeof (GtUword)="GT_WU"",
                  (GtUword) (sizeof (GtUword) * CHAR_BIT));
    if (gt_runsuffixerator(doesa,&so,NULL,logger,err) < 0)
    {
      haserr = true;
    }
    gt_logger_delete(logger);
    logger = NULL;
  } else
  {
    if (retval < 0)
    {
      haserr = true;
    }
  }
  gt_sfxoptions_delete(&so);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x68, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movl %esi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movb $0x0, 0x13(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x2d0330
movq 0x50(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2d02f8
jmp 0x2d0330
movq 0x36bca1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x245d0a(%rip), %rsi    # 0x516013
leaq 0x245eaf(%rip), %rdx    # 0x5161bf
leaq 0x2bbb5e(%rip), %rcx    # 0x58be75
leaq 0x2bba75(%rip), %r8     # 0x58bd93
movl $0x2d6, %r9d            # imm = 0x2D6
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d0332
movb 0x67(%rsp), %al
movl 0x60(%rsp), %edx
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r8
leaq 0x18(%rsp), %rdi
andb $0x1, %al
movzbl %al, %esi
callq 0x4e3e10
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x2d03d8
movb 0x18(%rsp), %al
movq 0x36bbcf(%rip), %rcx    # 0x63bf38
movq (%rcx), %rdx
leaq 0x247579(%rip), %rsi    # 0x5178ec
andb $0x1, %al
movzbl %al, %edi
callq 0xe7870
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x2bbb07(%rip), %rsi    # 0x58be95
movl $0x40, %edx
movb $0x0, %al
callq 0xe7cd0
movb 0x67(%rsp), %al
movq 0x8(%rsp), %rcx
movq 0x50(%rsp), %r8
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
andb $0x1, %al
movzbl %al, %edi
callq 0x2cead0
cmpl $0x0, %eax
jge 0x2d03c3
movb $0x1, 0x13(%rsp)
movq 0x8(%rsp), %rdi
callq 0xe7ed0
movq $0x0, 0x8(%rsp)
jmp 0x2d03e6
cmpl $0x0, 0x14(%rsp)
jge 0x2d03e4
movb $0x1, 0x13(%rsp)
jmp 0x2d03e6
leaq 0x18(%rsp), %rdi
callq 0x4e3db0
movb 0x13(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-run.c
// Function: gt_suflcptab2genomediff
static void gt_suflcptab2genomediff(void *data,
                                    const GtSuffixsortspace *sssp,
                                    const GtLcpvalues *tableoflcpvalues,
                                    GtUword bucketoffset,
                                    GtUword numberofsuffixes,
                                    GtUword posoffset)
{
  (void) gt_sfx_multiesa2shulengthdist(
                  (GtBUstate_shulen *) data,
                  gt_suffixsortspace_getptr_ulong(sssp,bucketoffset+posoffset),
                  gt_suffixsortspace_getptr_uint32(sssp,bucketoffset+posoffset),
                  gt_lcptab_getptr(tableoflcpvalues,bucketoffset),
                  numberofsuffixes,
                  NULL);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq 0x18(%rsp), %rsi
callq 0x2e9f40
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq 0x18(%rsp), %rsi
callq 0x2e9ff0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2c5ec0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
movq 0x20(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x23d9c0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-run.c
// Function: bwttab2file
static int bwttab2file(Outfileinfo *outfileinfo,
                       const GtSuffixsortspace *suffixsortspace,
                       GtReadmode readmode,
                       GtUword numberofsuffixes,
                       GT_UNUSED GtError *err)
{
  bool haserr = false;

  gt_error_check(err);
  if (outfileinfo->outfpbwttab != NULL)
  {
    GtUword startpos, pos;
    GtUchar cc = 0;

    for (pos=0; pos < numberofsuffixes; pos++)
    {
      startpos = gt_suffixsortspace_getdirect(suffixsortspace,pos);
      if (startpos == 0)
      {
        cc = (GtUchar) GT_UNDEFBWTCHAR;
      } else
      {
        if (outfileinfo->outfpbwttab != NULL)
        {
          /* Random access */
          cc = gt_encseq_get_encoded_char(outfileinfo->encseq,
                                          startpos - 1,
                                          readmode);
        }
      }
      if (outfileinfo->outfpbwttab != NULL)
      {
        gt_xfwrite(&cc,sizeof (GtUchar),(size_t) 1,outfileinfo->outfpbwttab);
      }
    }
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2d0521
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2d04e9
jmp 0x2d0521
movq 0x36bab0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x245b19(%rip), %rsi    # 0x516013
leaq 0x245cbe(%rip), %rdx    # 0x5161bf
leaq 0x2bba6e(%rip), %rcx    # 0x58bf76
leaq 0x2bb884(%rip), %r8     # 0x58bd93
movl $0xb5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d0523
movq 0x40(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2d05df
movb $0x0, 0x7(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2d05dd
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2e9a60
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2d0574
movb $-0x2, 0x7(%rsp)
jmp 0x2d05a1
movq 0x40(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2d059f
movq 0x40(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x10(%rsp), %rsi
subq $0x1, %rsi
movl 0x34(%rsp), %edx
callq 0xa9da0
movb %al, 0x7(%rsp)
jmp 0x2d05a1
movq 0x40(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2d05c8
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
leaq 0x7(%rsp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x126d30
jmp 0x2d05ca
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2d0541
jmp 0x2d05df
movb 0x1f(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbx
subq $0x70, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
andb $0x1, %cl
movb %cl, 0x63(%rsp)
andb $0x1, %al
movb %al, 0x62(%rsp)
movq %r8, 0x58(%rsp)
movq %r9, 0x50(%rsp)
movq 0x68(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0xb2530
movq %rax, %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl $0x4, %esi
leaq 0x2bb98d(%rip), %rdx    # 0x58c068
movl $0x638, %ecx            # imm = 0x638
callq 0xe83c0
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x2d0770
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x48(%rsp), %r8
movq 0x40(%rsp), %r9
movb 0x63(%rsp), %bl
movb 0x62(%rsp), %r11b
movq 0x58(%rsp), %r10
movq 0x50(%rsp), %rax
xorl %ecx, %ecx
andb $0x1, %bl
andb $0x1, %r11b
movl %ecx, %edi
movzbl %bl, %ebx
movl %ebx, (%rsp)
movzbl %r11b, %r11d
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x2d08b0
movq 0x28(%rsp), %rdi
callq 0x2d1600
movq 0x30(%rsp), %rax
addq $0x70, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sainseq_new_from_encseq
static GtSainseq *gt_sainseq_new_from_encseq(const GtEncseq *encseq,
                                             GtReadmode readmode)
{
  GtUword idx;
  GtSainseq *sainseq = (GtSainseq *) gt_malloc(sizeof *sainseq);

  sainseq->seqtype = GT_SAIN_ENCSEQ;
  sainseq->seq.encseq = encseq;
  sainseq->bare_encseq = NULL;
  sainseq->readmode = readmode;
  sainseq->totallength = gt_encseq_total_length(encseq);
  sainseq->numofchars = (GtUword) gt_encseq_alphabetnumofchars(encseq);

  gt_sain_allocate_tmpspace(sainseq,sainseq->totallength+GT_COMPAREOFFSET,
                                    sainseq->totallength);
  for (idx = 0; idx<sainseq->numofchars; idx++)
  {
    if (GT_ISDIRCOMPLEMENT(readmode))
    {
      sainseq->bucketsize[idx]
        = (GtUsainindextype)
          gt_encseq_charcount(encseq,(GtUchar) GT_COMPLEMENTBASE(idx));
    } else
    {
      sainseq->bucketsize[idx]
        = (GtUsainindextype) gt_encseq_charcount(encseq,(GtUchar) idx);
    }
  }
  return sainseq;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x58, %edi
leaq 0x2bb8df(%rip), %rsi    # 0x58c068
movl $0x74, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x2, 0x50(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x40(%rax)
movq 0x20(%rsp), %rdi
callq 0xa9d00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
callq 0xb0e80
movl %eax, %eax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq $0x100, %rsi            # imm = 0x100
movq 0x8(%rsp), %rax
movq (%rax), %rdx
callq 0x2d1fb0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2d08a5
cmpl $0x2, 0x1c(%rsp)
je 0x2d083f
cmpl $0x3, 0x1c(%rsp)
jne 0x2d086b
movq 0x20(%rsp), %rdi
movl $0x3, %eax
subq 0x10(%rsp), %rax
movzbl %al, %esi
callq 0xb0f60
movl %eax, %edx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2d0890
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl %al, %esi
callq 0xb0f60
movl %eax, %edx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2d0892
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2d0821
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2d16b1
movq (%rsp), %rax
testb $0x1, 0x54(%rax)
jne 0x2d1633
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x2baa3f(%rip), %rsi    # 0x58c068
movl $0x11d, %edx            # imm = 0x11D
callq 0xe88c0
movq (%rsp), %rax
testb $0x1, 0x55(%rax)
jne 0x2d1656
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x2baa1c(%rip), %rsi    # 0x58c068
movl $0x121, %edx            # imm = 0x121
callq 0xe88c0
movq (%rsp), %rax
testb $0x1, 0x56(%rax)
jne 0x2d1679
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x2ba9f9(%rip), %rsi    # 0x58c068
movl $0x125, %edx            # imm = 0x125
callq 0xe88c0
movq (%rsp), %rax
cmpl $0x1, 0x50(%rax)
je 0x2d169c
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x2ba9d6(%rip), %rsi    # 0x58c068
movl $0x129, %edx            # imm = 0x129
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x2ba9c1(%rip), %rsi    # 0x58c068
movl $0x12b, %edx            # imm = 0x12B
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_bare_encseq_sortsuffixes
GtUsainindextype *gt_sain_bare_encseq_sortsuffixes(
                                      const GtBareEncseq *bare_encseq,
                                      GtReadmode readmode,
                                      bool intermediatecheck,
                                      bool finalcheck,
                                      GtLogger *logger,
                                      GtTimer *timer)
{
  GtUword nonspecialentries, suftabentries, totallength;
  GtUsainindextype *suftab;
  GtSainseq *sainseq;

  totallength = gt_bare_encseq_total_length(bare_encseq);
  nonspecialentries = totallength -
                      gt_bare_encseq_specialcharacters(bare_encseq);
  suftabentries = totallength+1;
  suftab = (GtUsainindextype *) gt_calloc((size_t) suftabentries,
                                          sizeof *suftab);
  sainseq = gt_sainseq_new_from_bare_encseq(bare_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 %rbx
subq $0x70, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
andb $0x1, %cl
movb %cl, 0x63(%rsp)
andb $0x1, %al
movb %al, 0x62(%rsp)
movq %r8, 0x58(%rsp)
movq %r9, 0x50(%rsp)
movq 0x68(%rsp), %rdi
callq 0x2030f0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x68(%rsp), %rdi
callq 0x203210
movq %rax, %rcx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movl $0x4, %esi
leaq 0x2ba92d(%rip), %rdx    # 0x58c068
movl $0x65d, %ecx            # imm = 0x65D
callq 0xe83c0
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x2d17d0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x48(%rsp), %r8
movq 0x40(%rsp), %r9
movb 0x63(%rsp), %bl
movb 0x62(%rsp), %r11b
movq 0x58(%rsp), %r10
movq 0x50(%rsp), %rax
xorl %ecx, %ecx
andb $0x1, %bl
andb $0x1, %r11b
movl %ecx, %edi
movzbl %bl, %ebx
movl %ebx, (%rsp)
movzbl %r11b, %r11d
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x2d08b0
movq 0x28(%rsp), %rdi
callq 0x2d1600
movq 0x30(%rsp), %rax
addq $0x70, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sainseq_new_from_bare_encseq
static GtSainseq *gt_sainseq_new_from_bare_encseq(const GtBareEncseq
                                                     *bare_encseq,
                                                  GtReadmode readmode)
{
  GtUword idx;
  GtSainseq *sainseq = (GtSainseq *) gt_malloc(sizeof *sainseq);

  sainseq->seqtype = GT_SAIN_BARE_ENCSEQ;
  sainseq->seq.plainseq = gt_bare_encseq_sequence(bare_encseq);
  sainseq->totallength = gt_bare_encseq_total_length(bare_encseq);
  sainseq->numofchars = gt_bare_encseq_numofchars(bare_encseq);
  sainseq->bare_encseq = bare_encseq;
  sainseq->readmode = readmode;
  gt_sain_allocate_tmpspace(sainseq,sainseq->totallength+GT_COMPAREOFFSET,
                            sainseq->totallength);
  for (idx = 0; idx<sainseq->numofchars; idx++)
  {
    if (GT_ISDIRCOMPLEMENT(readmode))
    {
      sainseq->bucketsize[idx]
        = (GtUsainindextype) gt_bare_encseq_charcount(bare_encseq,
                                             (GtUchar) GT_COMPLEMENTBASE(idx));
    } else
    {
      sainseq->bucketsize[idx]
        = (GtUsainindextype) gt_bare_encseq_charcount(bare_encseq,
                                                      (GtUchar) idx);
    }
  }
  return sainseq;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x58, %edi
leaq 0x2ba87f(%rip), %rsi    # 0x58c068
movl $0xa8, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x3, 0x50(%rax)
movq 0x20(%rsp), %rdi
callq 0x203080
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rdi
callq 0x2030f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
callq 0x203140
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x40(%rax)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq $0x100, %rsi            # imm = 0x100
movq 0x8(%rsp), %rax
movq (%rax), %rdx
callq 0x2d1fb0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2d190d
cmpl $0x2, 0x1c(%rsp)
je 0x2d18a7
cmpl $0x3, 0x1c(%rsp)
jne 0x2d18d3
movq 0x20(%rsp), %rdi
movl $0x3, %eax
subq 0x10(%rsp), %rax
movzbl %al, %esi
callq 0x203190
movl %eax, %edx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2d18f8
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movzbl %al, %esi
callq 0x203190
movl %eax, %edx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2d18fa
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2d1889
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbx
subq $0x60, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
andb $0x1, %cl
movb %cl, 0x4f(%rsp)
andb $0x1, %al
movb %al, 0x4e(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x4, %esi
leaq 0x2ba6ff(%rip), %rdx    # 0x58c068
movl $0x67e, %ecx            # imm = 0x67E
callq 0xe83c0
movq %rax, 0x28(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x2d1a00
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %r8
movq 0x30(%rsp), %r9
movb 0x4f(%rsp), %bl
movb 0x4e(%rsp), %r11b
movq 0x40(%rsp), %r10
movq 0x38(%rsp), %rax
xorl %ecx, %ecx
andb $0x1, %bl
andb $0x1, %r11b
movl %ecx, %edi
movzbl %bl, %ebx
movl %ebx, (%rsp)
movzbl %r11b, %r11d
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
callq 0x2d08b0
movq 0x20(%rsp), %rdi
callq 0x2d1600
movq 0x28(%rsp), %rax
addq $0x60, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sainseq_new_from_plainseq
static GtSainseq *gt_sainseq_new_from_plainseq(const GtUchar *plainseq,
                                               GtUword len)
{
  const GtUchar *cptr;
  GtSainseq *sainseq = (GtSainseq *) gt_malloc(sizeof *sainseq);

  sainseq->seqtype = GT_SAIN_PLAINSEQ;
  sainseq->seq.plainseq = plainseq;
  sainseq->totallength = len;
  sainseq->numofchars = UCHAR_MAX+1;
  sainseq->bare_encseq = NULL;
  sainseq->readmode = GT_READMODE_FORWARD;
  gt_sain_allocate_tmpspace(sainseq,len+1,len);
  for (cptr = sainseq->seq.plainseq; cptr < sainseq->seq.plainseq + len; cptr++)
  {
    sainseq->bucketsize[*cptr]++;
  }
  return sainseq;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x58, %edi
leaq 0x2ba64e(%rip), %rsi    # 0x58c068
movl $0x93, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x0, 0x50(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x100, 0x8(%rax)       # imm = 0x100
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x40(%rax)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x1, %rsi
movq 0x18(%rsp), %rdx
callq 0x2d1fb0
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x38(%rcx), %rcx
addq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2d1ade
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2d1a9c
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_sain_checkmaxsequencelength
int gt_sain_checkmaxsequencelength(GtUword len,bool forencseq,GtError *err)
{
  GtUword maxsequencelength;

  if (forencseq)
  {
    maxsequencelength = (GtUword) (~GT_FIRSTBIT) - 1 - GT_COMPAREOFFSET;
  } else
  {
    maxsequencelength = (GtUword) (~GT_FIRSTBIT) - 1;
  }
  if (len > maxsequencelength)
  {
    gt_error_set(err,"sequence of size "GT_WU" is too long: sain algorithm "
                     "can only compute sequence of length up to "GT_WU"",
                     len,maxsequencelength);
    return -1;
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq %rdx, 0x8(%rsp)
testb $0x1, 0x17(%rsp)
je 0x2d1b1e
movabsq $0x7ffffffffffffefe, %rax # imm = 0x7FFFFFFFFFFFFEFE
movq %rax, (%rsp)
jmp 0x2d1b2c
movabsq $0x7ffffffffffffffe, %rax # imm = 0x7FFFFFFFFFFFFFFE
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
cmpq (%rsp), %rax
jbe 0x2d1b5d
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x2ba531(%rip), %rsi    # 0x58c07d
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d1b65
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2d1e4f
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x202540
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x2ba251(%rip), %rsi    # 0x58c068
movl $0x6ef, %edx            # imm = 0x6EF
callq 0xe88c0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x2ba238(%rip), %rsi    # 0x58c068
movl $0x6f0, %edx            # imm = 0x6F0
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x2ba223(%rip), %rsi    # 0x58c068
movl $0x6f1, %edx            # imm = 0x6F1
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-sain.c
// Function: gt_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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2d1ea9
movq 0x36a128(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x244191(%rip), %rsi    # 0x516013
leaq 0x2a4ed0(%rip), %rdx    # 0x576d59
leaq 0x2ba28d(%rip), %rcx    # 0x58c11d
leaq 0x2ba1d1(%rip), %r8     # 0x58c068
movl $0x6fa, %r9d            # imm = 0x6FA
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2d1eab
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2030f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x203210
movq %rax, %rcx
movq (%rsp), %rax
subq %rcx, %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)