LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_assignboundsforpart
void gt_bcktab_assignboundsforpart(GtBcktab *bcktab,
                                   GtCodetype mincode,
                                   GtCodetype maxcode)
{
  void *tmpleftborder;

  tmpleftborder = gt_Sfxmappedrange_map(bcktab->mappedleftborder,
                                        mincode,
                                        maxcode);
  if (bcktab->useulong)
  {
    bcktab->leftborder.ulongbounds = (GtUword *) tmpleftborder;
  } else
  {
    bcktab->leftborder.uintbounds = (uint32_t *) tmpleftborder;
  }
  if (bcktab->withspecialsuffixes)
  {
    void *tmpspecialcodes;

    tmpspecialcodes = gt_Sfxmappedrange_map(bcktab->mappedcountspecialcodes,
                                            mincode, maxcode);
    if (bcktab->useulong)
    {
      bcktab->ulongcountspecialcodes = (GtUword *) tmpspecialcodes;
    } else
    {
      bcktab->uintcountspecialcodes = (uint32_t *) tmpspecialcodes;
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2cc4d0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0xa2(%rax)
je 0x203b11
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x203b1e
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
testb $0x1, 0xa1(%rax)
je 0x203b77
movq 0x20(%rsp), %rax
movq 0xb8(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2cc4d0
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0xa2(%rax)
je 0x203b68
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x203b75
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x203b77
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_sizeoftable
uint64_t gt_bcktab_sizeoftable(unsigned int numofchars,
                               unsigned int prefixlength,
                               GtUword maxvalue,
                               bool withspecialsuffixes)
{
  GtUword numofallcodes, numofspecialcodes;
  uint64_t sizeofbuckettable;
  GtCodetype *basepower;

  if (withspecialsuffixes)
  {
    if (prefixlength >= 2U)
    {
      basepower = gt_initbasepower(numofchars,prefixlength-2);
    } else
    {
      basepower = NULL;
    }
    numofspecialcodes = gt_power_for_small_exponents(numofchars,prefixlength-1);
  } else
  {
    basepower = NULL;
    numofspecialcodes = 0;
  }
  numofallcodes = gt_power_for_small_exponents(numofchars,prefixlength);
  sizeofbuckettable
    = gt_bcktab_sizeoftable_generic(prefixlength,
                                    numofallcodes,
                                    numofspecialcodes,
                                    gt_bcktab_useulong(maxvalue),
                                    basepower,
                                    true,
                                    withspecialsuffixes);
  gt_free(basepower);
  return sizeofbuckettable;
}

// Assembly:
subq $0x58, %rsp
movb %cl, %al
movl %edi, 0x54(%rsp)
movl %esi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
je 0x203bde
cmpl $0x2, 0x50(%rsp)
jb 0x203bbe
movl 0x54(%rsp), %edi
movl 0x50(%rsp), %esi
subl $0x2, %esi
callq 0x25d6c0
movq %rax, 0x20(%rsp)
jmp 0x203bc7
movq $0x0, 0x20(%rsp)
movl 0x54(%rsp), %edi
movl 0x50(%rsp), %esi
subl $0x1, %esi
callq 0xec720
movq %rax, 0x30(%rsp)
jmp 0x203bf0
movq $0x0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movl 0x54(%rsp), %edi
movl 0x50(%rsp), %esi
callq 0xec720
movq %rax, 0x38(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x203d80
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %r8
movb 0x47(%rsp), %cl
movzbl %cl, %r9d
andl $0x1, %r9d
movq %rsp, %rcx
movl %r9d, (%rcx)
movzbl %al, %ecx
andl $0x1, %ecx
movl $0x1, %r9d
callq 0x203c90
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x36d1a3(%rip), %rsi    # 0x570e12
movl $0x142, %edx            # imm = 0x142
callq 0xe88c0
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_sizeoftable_generic
static uint64_t gt_bcktab_sizeoftable_generic(unsigned int prefixlength,
                                              GtUword numofallcodes,
                                              GtUword numofspecialcodes,
                                              bool useulong,
                                              const GtCodetype *basepower,
                                              bool countdistpfxidx,
                                              bool withspecialsuffixes)
{
  uint64_t sizeoftable;
  size_t sizeofbasetype;

  sizeofbasetype = useulong ? sizeof (GtUword) : sizeof (uint32_t);
  sizeoftable = (uint64_t) sizeofbasetype * (uint64_t) (numofallcodes + 1);
  if (withspecialsuffixes)
  {
    sizeoftable += sizeofbasetype * (uint64_t) numofspecialcodes;
    if (countdistpfxidx)
    {
      sizeoftable += (uint64_t) sizeofbasetype *
                                gt_bcktab_numofdistpfxidxcounters(basepower,
                                                                  prefixlength);
    }
  }
  return sizeoftable;
}

// Assembly:
subq $0x68, %rsp
movl %r9d, 0x14(%rsp)
movl %ecx, %eax
movl 0x14(%rsp), %ecx
movq %rdx, 0x18(%rsp)
movq %rsi, %rdx
movq 0x18(%rsp), %rsi
movq %rdx, 0x20(%rsp)
movl %edi, %r9d
movq 0x20(%rsp), %rdi
movb %al, %dl
movb 0x70(%rsp), %al
movl %r9d, 0x64(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
andb $0x1, %dl
movb %dl, 0x4f(%rsp)
movq %r8, 0x40(%rsp)
andb $0x1, %cl
movb %cl, 0x3f(%rsp)
andb $0x1, %al
movb %al, 0x3e(%rsp)
movb 0x4f(%rsp), %dl
movl $0x4, %eax
movl $0x8, %ecx
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x58(%rsp), %rcx
addq $0x1, %rcx
imulq %rcx, %rax
movq %rax, 0x30(%rsp)
testb $0x1, 0x3e(%rsp)
je 0x203d6b
movq 0x28(%rsp), %rax
imulq 0x50(%rsp), %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
testb $0x1, 0x3f(%rsp)
je 0x203d69
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x206aa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
imulq %rcx, %rax
addq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x203d6b
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_sizeofworkspace
GtUword gt_bcktab_sizeofworkspace(unsigned int prefixlength)
{
  size_t size = sizeof (GtCodetype) * (prefixlength+1);
  size += sizeof (GtCodetype) * prefixlength;
  size += sizeof (GtBcktab);
  size += prefixlength;
  return (GtUword) size;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
movq %rax, -0x10(%rsp)
movl -0x4(%rsp), %eax
shlq $0x3, %rax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
addq $0xc0, %rax
movq %rax, -0x10(%rsp)
movl -0x4(%rsp), %eax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_checkcountspecialcodes
void gt_bcktab_checkcountspecialcodes(const GtBcktab *bcktab)
{
  GtCodetype code;
  GtUword *count;

  if (bcktab->prefixlength >= 2U)
  {
    count = gt_malloc(sizeof (*count) * bcktab->prefixlength);
    for (code=0; code<bcktab->numofallcodes; code++)
    {
      pfxidxpartialsums(count, code, bcktab);
    }
    gt_free(count);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x2, 0x48(%rax)
jb 0x204b18
movq 0x10(%rsp), %rax
movl 0x48(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x36c359(%rip), %rsi    # 0x570e12
movl $0x2a9, %edx            # imm = 0x2A9
callq 0xe80f0
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x204b03
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x204b20
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x204ad0
movq (%rsp), %rdi
leaq 0x36c304(%rip), %rsi    # 0x570e12
movl $0x2ae, %edx            # imm = 0x2AE
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_map
GtBcktab *gt_bcktab_map(const char *indexname,
                        unsigned int numofchars,
                        unsigned int prefixlength,
                        GtUword maxvalue,
                        bool withspecialsuffixes,
                        GtError *err)
{
  GtBcktab *bcktab;

  bcktab = gt_bcktab_new_withinit(numofchars,prefixlength,maxvalue,
                                  withspecialsuffixes);
  bcktab->allocated = false;
  if (fillbcktabmapspecstartptr(bcktab, indexname, err) != 0)
  {
    gt_bcktab_delete(bcktab);
    return NULL;
  }
  if (withspecialsuffixes)
  {
    if (bcktab->ulongdistpfxidx != NULL)
    {
      ulong_setdistpfxidxptrs(bcktab->ulongdistpfxidx,
                              bcktab->ulongdistpfxidx[0],
                              bcktab->basepower,bcktab->prefixlength);
    } else
    {
      if (bcktab->uintdistpfxidx != NULL)
      {
        uint_setdistpfxidxptrs(bcktab->uintdistpfxidx,
                               bcktab->uintdistpfxidx[0],
                               bcktab->basepower,bcktab->prefixlength);
      }
    }
#ifdef CHECKCOUNTSPECIALCODES
    gt_bcktab_checkcountspecialcodes(bcktab);
#endif
  }
  return bcktab;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq %r9, 0x8(%rsp)
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
movq 0x18(%rsp), %rdx
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x2040d0
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x0, 0xa0(%rax)
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x204e70
cmpl $0x0, %eax
je 0x204ddd
movq (%rsp), %rdi
callq 0x204540
movq $0x0, 0x30(%rsp)
jmp 0x204e5e
testb $0x1, 0x17(%rsp)
je 0x204e55
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x204e18
movq (%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rsi
movq (%rsp), %rax
movq 0x70(%rax), %rdx
movq (%rsp), %rax
movl 0x48(%rax), %ecx
callq 0x204f70
jmp 0x204e4c
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x204e4a
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
movq (%rsp), %rax
movq 0x70(%rax), %rdx
movq (%rsp), %rax
movl 0x48(%rax), %ecx
callq 0x204ff0
jmp 0x204e4c
movq (%rsp), %rdi
callq 0x204a90
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: fillbcktabmapspecstartptr
static int fillbcktabmapspecstartptr(GtBcktab *bcktab,
                                     const char *indexname,
                                     GtError *err)
{
  bool haserr = false;
  GtStr *tmpfilename;

  gt_error_check(err);
  tmpfilename = gt_str_new_cstr(indexname);
  gt_str_append_cstr(tmpfilename,GT_BCKTABSUFFIX);
  if (gt_mapspec_read(assignbcktabmapspecification,
                      bcktab,
                      gt_str_get(tmpfilename),
                      bcktab->sizeofrep,
                      &bcktab->mappedptr,
                      err) != 0)
  {
    haserr = true;
  }
  gt_str_delete(tmpfilename);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x204ed8
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x204ea0
jmp 0x204ed8
movq 0x4370f9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x311162(%rip), %rsi    # 0x516013
leaq 0x311307(%rip), %rdx    # 0x5161bf
leaq 0x36c4bd(%rip), %rcx    # 0x57137c
leaq 0x36bf4c(%rip), %r8     # 0x570e12
movl $0x24a, %r9d            # imm = 0x24A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x204eda
movq 0x28(%rsp), %rdi
callq 0x11d510
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x36c4a1(%rip), %rsi    # 0x571396
callq 0x11d550
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11dee0
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x30(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x30(%rsp), %r8
addq $0xa8, %r8
movq 0x20(%rsp), %r9
leaq -0x647(%rip), %rdi      # 0x2048f0
callq 0xe9d20
cmpl $0x0, %eax
je 0x204f46
movb $0x1, 0x1f(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11f560
movb 0x1f(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: ulong_setdistpfxidxptrs
static void ulong_setdistpfxidxptrs(GtUword **ulongdistpfxidx,
                                    GtUword *ptr,
                                    const GtCodetype *basepower,
                                    unsigned int prefixlength)
{
  unsigned int idx;

  ulongdistpfxidx[0] = ptr;
  for (idx=1U; idx<prefixlength-1; idx++)
  {
    ulongdistpfxidx[idx] = ulongdistpfxidx[idx-1] + basepower[idx];
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x204fe7
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rsp), %rax
movl -0x20(%rsp), %ecx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdx
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x204f98
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: uint_setdistpfxidxptrs
static void uint_setdistpfxidxptrs(uint32_t **uintdistpfxidx,
                                   uint32_t *ptr,
                                   const GtCodetype *basepower,
                                   unsigned int prefixlength)
{
  unsigned int idx;

  uintdistpfxidx[0] = ptr;
  for (idx=1U; idx<prefixlength-1; idx++)
  {
    uintdistpfxidx[idx] = uintdistpfxidx[idx-1] + basepower[idx];
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, -0x20(%rsp)
movl -0x20(%rsp), %eax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x205067
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
movq -0x18(%rsp), %rax
movl -0x20(%rsp), %ecx
movq (%rax,%rcx,8), %rax
shlq $0x2, %rax
addq %rax, %rdx
movq -0x8(%rsp), %rax
movl -0x20(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
jmp 0x205018
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_show
void gt_bcktab_show(const GtBcktab *bcktab)
{
  unsigned int prefixindex;

  for (prefixindex=1U; prefixindex < bcktab->prefixlength-1; prefixindex++)
  {
    GtCodetype code;
    GtUword sum = 0, value;
    for (code = 0; code < bcktab->basepower[prefixindex]; code++)
    {
      value = gt_bcktab_distpfxidx_get(bcktab,prefixindex-1,code);
      sum += value;
      printf("distpfxidx[%u]["GT_WU"]="GT_WU"\n",prefixindex,code,value);
    }
    printf("sum "GT_WU"\n",sum);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
movl 0x48(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x205138
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x70(%rcx), %rcx
movl 0x1c(%rsp), %edx
cmpq (%rcx,%rdx,8), %rax
jae 0x205115
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
subl $0x1, %esi
movq 0x10(%rsp), %rdx
callq 0x205140
movq %rax, (%rsp)
movq (%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq (%rsp), %rcx
leaq 0x36be52(%rip), %rdi    # 0x570f50
movb $0x0, %al
callq 0x19070
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2050aa
movq 0x8(%rsp), %rsi
leaq 0x36be48(%rip), %rdi    # 0x570f69
movb $0x0, %al
callq 0x19070
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x205081
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_distpfxidx_get
static GtUword gt_bcktab_distpfxidx_get(const GtBcktab *bcktab,
                                              unsigned int prefixindex,
                                              GtCodetype ordercode)
{
  if (bcktab->ulongdistpfxidx != NULL)
  {
    return bcktab->ulongdistpfxidx[prefixindex][ordercode];
  }
  gt_assert(bcktab->uintdistpfxidx != NULL);
  return (GtUword) bcktab->uintdistpfxidx[prefixindex][ordercode];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x20517f
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
jmp 0x2051e5
jmp 0x205181
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x2051c5
movq 0x436e0c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x310e75(%rip), %rsi    # 0x516013
leaq 0x36c1f6(%rip), %rdx    # 0x57139b
leaq 0x36c20e(%rip), %rcx    # 0x5713ba
leaq 0x36bc5f(%rip), %r8     # 0x570e12
movl $0x75, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2051c7
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
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/bcktab.c
// Function: gt_bcktab_leftborder_show
void gt_bcktab_leftborder_show(const GtBcktab *bcktab)
{
  GtCodetype idx;

  for (idx=0; idx<bcktab->numofallcodes; idx++)
  {
    printf("leftborder[" FormatGtCodetype "]="GT_WU,idx,
                                    gt_bcktab_get_leftborder(bcktab,idx));
    if (idx > 0)
    {
      printf(" size " GT_WU,gt_bcktab_get_leftborder(bcktab,idx) -
                            gt_bcktab_get_leftborder(bcktab,idx-1));
    }
    printf("\n");
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x2052ab
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2037f0
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x36bd34(%rip), %rdi    # 0x570f72
movb $0x0, %al
callq 0x19070
cmpq $0x0, 0x18(%rsp)
jbe 0x20528a
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2037f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
subq $0x1, %rsi
callq 0x2037f0
movq 0x8(%rsp), %rsi
subq %rax, %rsi
leaq 0x3524ae(%rip), %rdi    # 0x557731
movb $0x0, %al
callq 0x19070
leaq 0x38dfe2(%rip), %rdi    # 0x593273
movb $0x0, %al
callq 0x19070
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x205202
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_remap_all
int gt_bcktab_remap_all(GtBcktab *bcktab,GtError *err)
{
  bool haserr = false;
  void *tmp;

  if (bcktab->mappedleftborder != NULL)
  {
    tmp = gt_Sfxmappedrange_map_entire(bcktab->mappedleftborder,err);
    if (bcktab->useulong)
    {
      bcktab->leftborder.ulongbounds = (GtUword *) tmp;
      if (bcktab->leftborder.ulongbounds == NULL)
      {
        haserr = true;
      }
    } else
    {
      bcktab->leftborder.uintbounds = (uint32_t *) tmp;
      if (bcktab->leftborder.uintbounds == NULL)
      {
        haserr = true;
      }
    }
  }
  if (!haserr &&
      bcktab->withspecialsuffixes && bcktab->mappedcountspecialcodes != NULL)
  {
    tmp = gt_Sfxmappedrange_map_entire(bcktab->mappedcountspecialcodes,err);
    if (bcktab->useulong)
    {
      bcktab->ulongcountspecialcodes = (GtUword *) tmp;
      if (bcktab->ulongcountspecialcodes == NULL)
      {
        gt_fa_xmunmap(bcktab->leftborder.ulongbounds);
        haserr = true;
      }
    } else
    {
      bcktab->uintcountspecialcodes = (uint32_t *) tmp;
      if (bcktab->uintcountspecialcodes == NULL)
      {
        gt_fa_xmunmap(bcktab->leftborder.uintbounds);
        haserr = true;
      }
    }
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x20533d
movq 0x20(%rsp), %rax
movq 0xb0(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x2cb9f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0xa2(%rax)
je 0x20531c
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x20531a
movb $0x1, 0x17(%rsp)
jmp 0x20533b
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x205339
movb $0x1, 0x17(%rsp)
jmp 0x20533b
jmp 0x20533d
testb $0x1, 0x17(%rsp)
jne 0x2053f5
movq 0x20(%rsp), %rax
testb $0x1, 0xa1(%rax)
je 0x2053f5
movq 0x20(%rsp), %rax
cmpq $0x0, 0xb8(%rax)
je 0x2053f5
movq 0x20(%rsp), %rax
movq 0xb8(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x2cb9f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0xa2(%rax)
je 0x2053c5
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2053c3
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xdb2a0
movb $0x1, 0x17(%rsp)
jmp 0x2053f3
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x2053f1
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0xdb2a0
movb $0x1, 0x17(%rsp)
jmp 0x2053f3
jmp 0x2053f5
movb 0x17(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_distpfxidx_increment
static void gt_bcktab_distpfxidx_increment(const GtBcktab *bcktab,
                                           unsigned int prefixindex,
                                           GtCodetype ordercode)
{
  if (bcktab->ulongdistpfxidx != NULL)
  {
    bcktab->ulongdistpfxidx[prefixindex][ordercode]++;
  } else
  {
    gt_assert(bcktab->uintdistpfxidx != NULL);
    bcktab->uintdistpfxidx[prefixindex][ordercode]++;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2056d0
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x205736
jmp 0x2056d2
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x205716
movq 0x4368bb(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x310924(%rip), %rsi    # 0x516013
leaq 0x36bca5(%rip), %rdx    # 0x57139b
leaq 0x36bcd6(%rip), %rcx    # 0x5713d3
leaq 0x36b70e(%rip), %r8     # 0x570e12
movl $0x82, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x205718
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq (%rsp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_addfinalspecials
void gt_bcktab_addfinalspecials(GtBcktab *bcktab,
                                GtUword specialcharacters)
{
  if (bcktab->withspecialsuffixes)
  {
    GtCodetype specialcode;

    gt_assert(bcktab->filltable[0] >= (GtCodetype) (bcktab->numofchars-1));
    specialcode = GT_FROMCODE2SPECIALCODE(bcktab->filltable[0],
                                          bcktab->numofchars);
    if (bcktab->ulongcountspecialcodes != NULL)
    {
      bcktab->ulongcountspecialcodes[specialcode]
        += (GtUword) (specialcharacters + 1);
    } else
    {
      gt_assert(bcktab->uintcountspecialcodes != NULL);
      bcktab->uintcountspecialcodes[specialcode]
        += (uint32_t) (specialcharacters + 1);
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0xa1(%rax)
je 0x2058aa
jmp 0x205762
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movl 0x4c(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jae 0x2057b8
movq 0x436819(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x310882(%rip), %rsi    # 0x516013
leaq 0x36b904(%rip), %rdx    # 0x57109c
leaq 0x36b939(%rip), %rcx    # 0x5710d8
leaq 0x36b66c(%rip), %r8     # 0x570e12
movl $0x390, %r9d            # imm = 0x390
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2057ba
movq 0x20(%rsp), %rax
cmpl $0x4, 0x4c(%rax)
jne 0x2057dc
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
shrq $0x2, %rax
movq %rax, 0x8(%rsp)
jmp 0x20580a
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movl 0x4c(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
subq %rcx, %rax
movq 0x20(%rsp), %rcx
movl 0x4c(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x205841
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x2058a8
jmp 0x205843
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x205887
movq 0x43674a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3107b3(%rip), %rsi    # 0x516013
leaq 0x36b80f(%rip), %rdx    # 0x571076
leaq 0x36b86a(%rip), %rcx    # 0x5710d8
leaq 0x36b59d(%rip), %r8     # 0x570e12
movl $0x399, %r9d            # imm = 0x399
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x205889
movq 0x18(%rsp), %rax
addq $0x1, %rax
movl %eax, %edx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x2058aa
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_calcboundaries
void gt_bcktab_calcboundaries(GtBucketspecification *bucketspec,
                              const GtBcktab *bcktab,
                              GtCodetype code)
{
  gt_assert(code != bcktab->numofallcodes);
  (void) gt_bcktab_calcboundsparts(bucketspec,
                                   bcktab,
                                   code,
                                   bcktab->numofallcodes, /*code<numofallcodes*/
                                   0,  /* not necessary */
                                   bcktab->withspecialsuffixes
                                    ? (unsigned int) (code % bcktab->numofchars)
                                    : 0);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jne 0x205bdb
movq 0x4363f6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x31045f(%rip), %rsi    # 0x516013
leaq 0x36b571(%rip), %rdx    # 0x57112c
leaq 0x36b588(%rip), %rcx    # 0x57114a
leaq 0x36b249(%rip), %r8     # 0x570e12
movl $0x3db, %r9d            # imm = 0x3DB
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x205bdd
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
testb $0x1, 0xa1(%rax)
je 0x205c31
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x4c(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0xc(%rsp)
jmp 0x205c39
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x205c39
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %r9d
xorl %eax, %eax
movl %eax, %r8d
callq 0x2058b0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_codedownscale
GtCodetype gt_bcktab_codedownscale(const GtBcktab *bcktab,
                                   GtCodetype code,
                                   unsigned int prefixindex,
                                   unsigned int maxprefixlen)
{
  unsigned int remain;

  code -= bcktab->filltable[maxprefixlen];
  remain = maxprefixlen-prefixindex;
  code %= (bcktab->filltable[remain]+1);
  code *= bcktab->basepower[remain];
  code += bcktab->filltable[prefixindex];
  return code;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x78(%rax), %rax
movl -0x18(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rsp)
movl -0x18(%rsp), %eax
subl -0x14(%rsp), %eax
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq 0x78(%rax), %rax
movl -0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
addq $0x1, %rcx
movq -0x10(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rdx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x70(%rax), %rax
movl -0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
imulq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq 0x78(%rax), %rax
movl -0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_singletonmaxprefixindex
unsigned int gt_bcktab_singletonmaxprefixindex(const GtBcktab *bcktab,
                                               GtCodetype code)
{
  if (bcktab->prefixlength > 2U)
  {
    GtCodetype ordercode, divisor;
    unsigned int prefixindex;

    for (prefixindex=bcktab->prefixlength-2; prefixindex>=1U; prefixindex--)
    {
      if (code >= bcktab->filltable[prefixindex])
      {
        ordercode = code - bcktab->filltable[prefixindex];
        divisor = bcktab->filltable[prefixindex] + 1;
        if (ordercode % divisor == 0)
        {
          ordercode /= divisor;
          if (gt_bcktab_distpfxidx_get(bcktab,prefixindex-1,ordercode) > 0)
          {
            return prefixindex;
          }
        }
      } else
      {
        break;
      }
    }
  }
  return bcktab->prefixlength-1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x2, 0x48(%rax)
jbe 0x205fb0
movq 0x28(%rsp), %rax
movl 0x48(%rax), %eax
subl $0x2, %eax
movl %eax, 0xc(%rsp)
cmpl $0x1, 0xc(%rsp)
jb 0x205fae
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x78(%rcx), %rcx
movl 0xc(%rsp), %edx
cmpq (%rcx,%rdx,8), %rax
jb 0x205f9a
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x78(%rcx), %rcx
movl 0xc(%rsp), %edx
subq (%rcx,%rdx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x78(%rax), %rax
movl 0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x10(%rsp)
cmpq $0x0, %rdx
jne 0x205f98
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %esi
subl $0x1, %esi
movq 0x18(%rsp), %rdx
callq 0x205140
cmpq $0x0, %rax
jbe 0x205f96
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x205fbf
jmp 0x205f98
jmp 0x205f9c
jmp 0x205fae
jmp 0x205f9e
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x205eec
jmp 0x205fb0
movq 0x28(%rsp), %rax
movl 0x48(%rax), %eax
subl $0x1, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_distpfxidxpartialsums
GtUword gt_bcktab_distpfxidxpartialsums(const GtBcktab *bcktab,
                                              GtCodetype code,
                                              unsigned int lowerbound)
{
  GtCodetype ordercode, divisor;
  GtUword sum = 0;
  unsigned int prefixindex;

  for (prefixindex=bcktab->prefixlength-2; prefixindex>lowerbound;
       prefixindex--)
  {
    if (code >= bcktab->filltable[prefixindex])
    {
      ordercode = code - bcktab->filltable[prefixindex];
      divisor = bcktab->filltable[prefixindex] + 1;
      if (ordercode % divisor == 0)
      {
        ordercode /= divisor;
        sum += gt_bcktab_distpfxidx_get(bcktab,prefixindex-1,ordercode);
      }
    } else
    {
      break;
    }
  }
  return sum;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl 0x48(%rax), %eax
subl $0x2, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x24(%rsp), %eax
jbe 0x2060b3
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x78(%rcx), %rcx
movl 0x4(%rsp), %edx
cmpq (%rcx,%rdx,8), %rax
jb 0x20609f
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x78(%rcx), %rcx
movl 0x4(%rsp), %edx
subq (%rcx,%rdx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x78(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x10(%rsp)
cmpq $0x0, %rdx
jne 0x20609d
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movl 0x4(%rsp), %esi
subl $0x1, %esi
movq 0x18(%rsp), %rdx
callq 0x205140
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2060a1
jmp 0x2060b3
jmp 0x2060a3
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x205ffa
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_leftborderpartialsums
GtUword gt_bcktab_leftborderpartialsums(
                             GtUword *saved_bucketswithoutwholeleaf,
                             GtUword *numofsuffixestosort,
                             GtBcktab *bcktab)
{
  GtUword code, largestbucketsize, sumbuckets, saved = 0, currentsize;

  gt_assert(bcktab->numofallcodes > 0);
  largestbucketsize = sumbuckets = gt_bcktab_get_leftborder(bcktab,0);
  for (code = 1UL; code < bcktab->numofallcodes; code++)
  {
    currentsize = gt_bcktab_get_leftborder(bcktab,code);
    sumbuckets += currentsize;
    if (largestbucketsize < currentsize)
    {
      largestbucketsize = currentsize;
    }
    gt_bcktab_leftborder_assign(&bcktab->leftborder,code,sumbuckets);
  }
  gt_bcktab_leftborder_assign(&bcktab->leftborder,bcktab->numofallcodes,
                              sumbuckets);
  if (saved_bucketswithoutwholeleaf != NULL)
  {
    *saved_bucketswithoutwholeleaf = saved;
  }
  if (numofsuffixestosort != NULL)
  {
    *numofsuffixestosort = sumbuckets;
  }
  return largestbucketsize;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
cmpq $0x0, 0x58(%rax)
ja 0x206670
movq 0x435961(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30f9ca(%rip), %rsi    # 0x516013
leaq 0x36ab9b(%rip), %rdx    # 0x5711eb
leaq 0x36abae(%rip), %rcx    # 0x571205
leaq 0x36a7b4(%rip), %r8     # 0x570e12
movl $0x501, %r9d            # imm = 0x501
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x206672
movq 0x30(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2037f0
movq %rax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq $0x1, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x206700
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2037f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x2066dc
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2036c0
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x206693
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0x2036c0
cmpq $0x0, 0x40(%rsp)
je 0x20672d
movq 0x10(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
cmpq $0x0, 0x38(%rsp)
je 0x206742
movq 0x18(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_sizeforlcpvalues
size_t gt_bcktab_sizeforlcpvalues(const GtBcktab *bcktab)
{
  size_t sizespeciallcps, sizelcps;

  sizespeciallcps = sizeof (uint8_t) *
                    bcktab->maxbucketinfo.specialsmaxbucketsize;
  sizelcps
    = sizeof (GtUword) * gt_bcktab_nonspecialsmaxsize(bcktab);
  return GT_MAX(sizelcps,sizespeciallcps);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x90(%rax), %rax
shlq $0x0, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x205e90
shlq $0x3, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jbe 0x206799
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2067a3
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_transformcode
static GtUword gt_bcktab_transformcode(GtUword code,
                                             const void *data)
{
  unsigned int numofchars, *numofcharptr = (unsigned int *) data;

  numofchars = *numofcharptr;
  if (code >= (GtUword) (numofchars - 1))
  {
    return GT_FROMCODE2SPECIALCODE(code,numofchars);
  } else
  {
    return 0;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rsp)
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
cmpq %rcx, %rax
jb 0x206a84
cmpl $0x4, -0x1c(%rsp)
jne 0x206a59
movq -0x10(%rsp), %rax
shrq $0x2, %rax
movq %rax, -0x30(%rsp)
jmp 0x206a78
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
subq %rcx, %rax
movl -0x1c(%rsp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x206a8d
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_numofdistpfxidxcounters
static GtUword gt_bcktab_numofdistpfxidxcounters(
                                             const GtCodetype *basepower,
                                             unsigned int prefixlength)
{
  if (prefixlength > 2U)
  {
    GtUword numofcounters = 0;
    unsigned int idx;

    for (idx=1U; idx < prefixlength-1; idx++)
    {
      numofcounters += basepower[idx];
    }
    return numofcounters;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x2, -0x14(%rsp)
jbe 0x206b00
movq $0x0, -0x20(%rsp)
movl $0x1, -0x24(%rsp)
movl -0x24(%rsp), %eax
movl -0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x206af4
movq -0x10(%rsp), %rax
movl -0x24(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x206ac1
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x206b09
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.c
// Function: fromcode2countspecialcodes
static GtUword fromcode2countspecialcodes(GtCodetype code,
                                                const GtBcktab *bcktab)
{
  if (code >= bcktab->filltable[bcktab->prefixlength-1])
  {
    GtCodetype ordercode = code - bcktab->filltable[bcktab->prefixlength-1];
    GtCodetype divisor = bcktab->filltable[bcktab->prefixlength-1] + 1;
    if (ordercode % divisor == 0)
    {
      ordercode /= divisor;
      if (bcktab->ulongcountspecialcodes != NULL)
      {
        return bcktab->ulongcountspecialcodes[ordercode];
      } else
      {
        gt_assert(bcktab->uintcountspecialcodes != NULL);
        return (GtUword) bcktab->uintcountspecialcodes[ordercode];
      }
    }
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x78(%rcx), %rcx
movq 0x10(%rsp), %rdx
movl 0x48(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
cmpq (%rcx,%rdx,8), %rax
jb 0x206c5a
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x78(%rcx), %rcx
movq 0x10(%rsp), %rdx
movl 0x48(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
subq (%rcx,%rdx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x48(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq (%rsp)
cmpq $0x0, %rdx
jne 0x206c58
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x206bf8
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
jmp 0x206c63
jmp 0x206bfa
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x206c3e
movq 0x435393(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30f3fc(%rip), %rsi    # 0x516013
leaq 0x36a458(%rip), %rdx    # 0x571076
leaq 0x36a73c(%rip), %rcx    # 0x571361
leaq 0x36a1e6(%rip), %r8     # 0x570e12
movl $0x26b, %r9d            # imm = 0x26B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x206c40
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, 0x20(%rsp)
jmp 0x206c63
jmp 0x206c5a
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/cgr_spacedseed.c
// Function: singlequerymatchspacedseed
static void singlequerymatchspacedseed(Limdfsresources *limdfsresources,
                                       const AbstractDfstransformer *dfst,
                                       const GtUchar *query,
                                       GtUword querylen,
                                       const Spacedseed *spse)
{
  const GtUchar *qptr;
  GtUword offset, skipvalue;

  if (spse->seedwidth > querylen)
  {
    return;
  }
  qptr = query;
  offset = 0;
  while (qptr <= query + querylen - spse->seedwidth)
  {
    skipvalue = gt_containsspecialbytestring(qptr,offset,spse->seedwidth);
    if (skipvalue == spse->seedwidth)
    {
      offset = spse->seedwidth-1;
      singlewindowmatchspacedseed(limdfsresources,dfst,qptr,spse);
      qptr++;
    } else
    {
      offset = 0;
      qptr += (skipvalue+1);
    }
  }
}

// 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 0x20(%rsp), %rax
movq (%rax), %rax
cmpq 0x28(%rsp), %rax
jbe 0x2072f1
jmp 0x2073af
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
addq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rsi
xorl %edx, %edx
subq (%rsi), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
ja 0x2073af
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
callq 0x207400
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x20738e
movq 0x20(%rsp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x2074c0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2073aa
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x207304
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/chardef_api.h
// Function: gt_containsspecialbytestring
static inline GtUword
                            gt_containsspecialbytestring(const GtUchar *seq,
                                                      GtUword offset,
                                                      GtUword len)
{
  const GtUchar *sptr;

  gt_assert(offset < len);
  for (sptr=seq+offset; sptr < seq + len; sptr++)
  {
    if (GT_ISSPECIAL(*sptr))
    {
      return (GtUword) (sptr - seq);
    }
  }
  return len;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x207457
movq 0x434b7a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30ebe3(%rip), %rsi    # 0x516013
leaq 0x36a02d(%rip), %rdx    # 0x571464
leaq 0x36a033(%rip), %rcx    # 0x571471
leaq 0x36a049(%rip), %r8     # 0x57148e
movl $0x50, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x207459
movq 0x18(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
addq 0x8(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2074ab
movq (%rsp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
jl 0x20749b
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x2074b5
jmp 0x20749d
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x207467
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/cgr_spacedseed.c
// Function: singlewindowmatchspacedseed
static void singlewindowmatchspacedseed(Limdfsresources *limdfsresources,
                                        const AbstractDfstransformer *dfst,
                                        const GtUchar *qptr,
                                        const Spacedseed *spse)
{
  gt_indexbasedspacedseeds(limdfsresources,
                        qptr,
                        spse->seedbitvector,
                        spse->seedwidth,
                        dfst);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %r8
callq 0x255c50
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain_matchtable_new
GtChain2Dimmatchtable *gt_chain_matchtable_new(GtUword numberofmatches)
{
  GtChain2Dimmatchtable *matchtable = gt_malloc(sizeof (*matchtable));
  matchtable->matches = gt_malloc(sizeof (*matchtable->matches) *
                                  numberofmatches);
  matchtable->nextfree = 0;
  matchtable->allocated = numberofmatches;
  matchtable->largestdim0 = matchtable->largestdim1 = 0;
  matchtable->previouscount = NULL;
  matchtable->previousbound = NULL;
  matchtable->previoustab = NULL;
  matchtable->allprevious = 0;
  return matchtable;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x48, %edi
leaq 0x369fe3(%rip), %rsi    # 0x571508
movl $0x88, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
imulq $0x50, 0x10(%rsp), %rdi
leaq 0x369fc7(%rip), %rsi    # 0x571508
movl $0x8a, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)