LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-copysort.c
// Function: gt_copysort_checkhardwork
bool gt_copysort_checkhardwork(const GtBucketspec2 *bucketspec2,
                               GtCodetype code)
{
  if (bucketspec2->prefixlength > 2U)
  {
    return bucketspec2->subbuckettab[0][code / bucketspec2->expandfactor].
                                        hardworktodo;
  } else
  {
    return bucketspec2->subbuckettab[0][code].hardworktodo;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x2, 0x1c(%rax)
jbe 0x2bbeef
movq -0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
xorl %edx, %edx
divq 0x28(%rcx)
movq %rax, %rcx
movq -0x20(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x2bbf0f
movq -0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movb (%rax), %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-copysort.c
// Function: getendidx
static GtUword getendidx(const GtBucketspec2 *bucketspec2,
                        unsigned int first,
                        unsigned int second)
{
  gt_assert(first < bucketspec2->numofchars);
  gt_assert(second <= bucketspec2->numofchars);
  if (second < bucketspec2->numofchars)
  {
    return bucketspec2->subbuckettab[first][second].bucketend;
  }
  return bucketspec2->superbuckettab[first].bucketend;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jb 0x2bc5f6
movq 0x37f9db(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x259a44(%rip), %rsi    # 0x516013
leaq 0x2cd0ee(%rip), %rdx    # 0x5896c4
leaq 0x2cd107(%rip), %rcx    # 0x5896e4
leaq 0x2cce22(%rip), %r8     # 0x589406
movl $0x5d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2bc5f8
jmp 0x2bc5fa
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jbe 0x2bc63f
movq 0x37f992(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2599fb(%rip), %rsi    # 0x516013
leaq 0x2cd0cf(%rip), %rdx    # 0x5896ee
leaq 0x2cd0be(%rip), %rcx    # 0x5896e4
leaq 0x2ccdd9(%rip), %r8     # 0x589406
movl $0x5e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2bc641
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x2bc674
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2bc691
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x4(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-copysort.c
// Function: getstartidx
static GtUword getstartidx(const GtBucketspec2 *bucketspec2,
                                 unsigned int first,
                                 unsigned int second)
{
  gt_assert(first < bucketspec2->numofchars);
  gt_assert(second <= bucketspec2->numofchars);
  if (second > 0)
  {
    return bucketspec2->subbuckettab[first][second-1].bucketend;
  }
  if (first > 0)
  {
    return bucketspec2->superbuckettab[first-1].bucketend;
  }
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jb 0x2bc6f6
movq 0x37f8db(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x259944(%rip), %rsi    # 0x516013
leaq 0x2ccfee(%rip), %rdx    # 0x5896c4
leaq 0x2cd033(%rip), %rcx    # 0x589710
leaq 0x2ccd22(%rip), %r8     # 0x589406
movl $0x4c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2bc6f8
jmp 0x2bc6fa
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jbe 0x2bc73f
movq 0x37f892(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2598fb(%rip), %rsi    # 0x516013
leaq 0x2ccfcf(%rip), %rdx    # 0x5896ee
leaq 0x2ccfea(%rip), %rcx    # 0x589710
leaq 0x2cccd9(%rip), %r8     # 0x589406
movl $0x4d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2bc741
cmpl $0x0, (%rsp)
jbe 0x2bc772
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x4(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl (%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2bc7a6
cmpl $0x0, 0x4(%rsp)
jbe 0x2bc79d
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2bc7a6
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-copysort.c
// Function: gt_copysort_delete
void gt_copysort_delete(GtBucketspec2 *bucketspec2)
{
  gt_assert(bucketspec2 != NULL);
  gt_array2dim_delete(bucketspec2->subbuckettab);
  gt_free(bucketspec2->superbuckettab);
  gt_free(bucketspec2->order);
  gt_free(bucketspec2);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2bcc54
movq 0x37f37d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2593e6(%rip), %rsi    # 0x516013
leaq 0x2cc8a1(%rip), %rdx    # 0x5894d5
leaq 0x2cc8ae(%rip), %rcx    # 0x5894e9
leaq 0x2cc7c4(%rip), %r8     # 0x589406
movl $0x216, %r9d            # imm = 0x216
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2bcc56
movq (%rsp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rdi
leaq 0x2cc79e(%rip), %rsi    # 0x589406
movl $0x217, %edx            # imm = 0x217
callq 0xe88c0
movq (%rsp), %rax
movq 0x40(%rax), %rdi
leaq 0x2cc785(%rip), %rsi    # 0x589406
movl $0x217, %edx            # imm = 0x217
callq 0xe88c0
movq (%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0x2cc76c(%rip), %rsi    # 0x589406
movl $0x218, %edx            # imm = 0x218
callq 0xe88c0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x2cc753(%rip), %rsi    # 0x589406
movl $0x219, %edx            # imm = 0x219
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x2cc73e(%rip), %rsi    # 0x589406
movl $0x21a, %edx            # imm = 0x21A
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-copysort.c
// Function: superbucketsize
static GtUword superbucketsize(const GtBucketspec2 *bucketspec2,
                                     unsigned int bucketnum)
{
  if (bucketnum == 0)
  {
    return bucketspec2->superbuckettab[0].bucketend;
  }
  return bucketspec2->superbuckettab[bucketnum].bucketend -
         bucketspec2->superbuckettab[bucketnum-1].bucketend;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jne 0x2bd044
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x2bd07e
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movl -0x14(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x38(%rcx), %rcx
movl -0x14(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
shlq $0x4, %rdx
addq %rdx, %rcx
subq 0x8(%rcx), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_differencecover_vparamverify
static int gt_differencecover_vparamverify(const GtDifferencecover *dcov,
                                           GtError *err)
{
  if (dcov->vparam < dcov->prefixlength)
  {
    gt_error_set(err,"difference cover modulo %u is too small, use larger "
                     "parameter for option -dc",dcov->vparam);
    return -1;
  }
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x2bdbc1
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %edx
leaq 0x2cbfad(%rip), %rsi    # 0x589b5d
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x2bdbc9
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_differencecover_check
void gt_differencecover_check(const GtEncseq *encseq,GtReadmode readmode)
{
  GtDifferencecover *dcov;
  size_t logmod;
  const size_t startlogmod = (size_t) 4;
  unsigned int vparam;
  bool withcheck = true;

  printf("sizeof (differencecovertab)="GT_WU"\n",
          (GtUword) sizeof (differencecovertab));
  for (logmod = startlogmod;
       logmod < sizeof (differencecoversizes)/sizeof (differencecoversizes[0]);
       logmod++)
  {
    vparam = 1U << logmod;
    dcov = gt_differencecover_new(vparam,encseq,readmode,0,NULL);
    if (dcov == NULL)
    {
      fprintf(stderr,"no difference cover for v=%u\n",vparam);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    printf("v=%u (size=%u)\n",dcov->vparam,dcov->size);
    if (withcheck)
    {
      dc_validate_samplepositions(dcov);
    }
    dc_differencecover_sortsample(dcov,NULL,NULL,NULL,withcheck);
    gt_differencecover_delete(dcov);
  }
  printf("# %u difference covers checked\n",
          (unsigned int) (logmod - startlogmod));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq $0x4, 0x10(%rsp)
movb $0x1, 0xb(%rsp)
leaq 0x2ca069(%rip), %rdi    # 0x58999b
movl $0x604, %esi            # imm = 0x604
movb $0x0, %al
callq 0x19070
movq $0x4, 0x18(%rsp)
cmpq $0x10, 0x18(%rsp)
jae 0x2bfa18
movq 0x18(%rsp), %rax
movl %eax, %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x2bd090
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2bf9b1
movq 0x37c60e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movl 0xc(%rsp), %edx
leaq 0x2ca01c(%rip), %rsi    # 0x5899bc
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq 0x20(%rsp), %rax
movl (%rax), %esi
movq 0x20(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x2ca013(%rip), %rdi    # 0x5899da
movb $0x0, %al
callq 0x19070
testb $0x1, 0xb(%rsp)
je 0x2bf9df
movq 0x20(%rsp), %rdi
callq 0x2bfa40
movq 0x20(%rsp), %rdi
movb 0xb(%rsp), %al
xorl %ecx, %ecx
andb $0x1, %al
movq %rcx, %rsi
movq %rcx, %rdx
movzbl %al, %r8d
callq 0x2bdbe0
movq 0x20(%rsp), %rdi
callq 0x2bd790
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2bf947
movq 0x18(%rsp), %rax
subq $0x4, %rax
movl %eax, %esi
leaq 0x2c9fc0(%rip), %rdi    # 0x5899ea
movb $0x0, %al
callq 0x19070
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_differencecover_sortunsortedbucket
void gt_differencecover_sortunsortedbucket(GtSuffixsortspace *sssp,
                                           GtLcpvalues *sssplcpvalues,
                                           const GtDifferencecover *dcov,
                                           GtUword blisbl,
                                           GtUword width,
                                           GT_UNUSED GtUword depth)
{
  const GtUword bucketleftidx = gt_suffixsortspace_bucketleftidx_get(sssp);

  gt_assert(dcov != NULL &&
            depth >= (GtUword) dcov->vparam &&
            dcov->diff2pos != NULL &&
            width >= 2UL &&
            sssp != NULL &&
            blisbl >= bucketleftidx);
  /* blisbl = bucketleftindex + subbucketleft already contains
     bucketleftindex, therefore we cannot use
     gt_suffixsortspace_set or
     gt_suffixsortspace_get as these use the index
     bucketleftindex + subbucketleft + idx - partoffset
     = blisbl - partoffset + idx. Thus, instead we use the functions
     to directly access the suffix sortspace. */
  QSORTNAME(gt_inlinedarr_qsort_r) (sssp, sssplcpvalues, dcov, 6UL, false,
                                    blisbl - bucketleftidx, width);
}

// 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), %rdi
callq 0x2ea3a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2c0392
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jb 0x2c0392
movq 0x30(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2c0392
cmpq $0x2, 0x20(%rsp)
jb 0x2c0392
cmpq $0x0, 0x40(%rsp)
je 0x2c0392
movq 0x28(%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x2c03ca
movq 0x37bc07(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x255c70(%rip), %rsi    # 0x516013
leaq 0x2c96dd(%rip), %rdx    # 0x589a87
leaq 0x2c975b(%rip), %rcx    # 0x589b0c
leaq 0x2c9403(%rip), %r8     # 0x5897bb
movl $0x8d9, %r9d            # imm = 0x8D9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c03cc
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %r9
subq 0x10(%rsp), %r9
movq 0x20(%rsp), %rax
movl $0x6, %ecx
xorl %r8d, %r8d
movq %rax, (%rsp)
callq 0x2c0400
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_inl_dc_queue_new
static GtInlDCQueue *gt_inl_dc_queue_new(GtUword queuesize)
{
  GtInlDCQueue *q;

  q = gt_malloc(sizeof (*q));
  gt_assert(queuesize > 0);
  q->queuespace = gt_malloc(sizeof (*q->queuespace) * queuesize);
  q->noofelements = 0;
  q->queuesize = queuesize;
  q->dequeueindex = q->enqueueindex = queuesize - 1;
  return q;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x28, %edi
leaq 0x2c76c6(%rip), %rsi    # 0x5897bb
movl $0x83, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
ja 0x2c2144
movq 0x379e8d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x253ef6(%rip), %rsi    # 0x516013
leaq 0x2c82ea(%rip), %rdx    # 0x58a40e
leaq 0x2c7c9f(%rip), %rcx    # 0x589dca
leaq 0x2c7689(%rip), %r8     # 0x5897bb
movl $0x84, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c2146
movq 0x10(%rsp), %rdi
shlq $0x4, %rdi
leaq 0x2c7665(%rip), %rsi    # 0x5897bb
movl $0x85, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.h
// Function: gt_bcktab_leftborder_addcode
static inline void gt_bcktab_leftborder_addcode(GtLeftborder *lb,
                                                             GtCodetype code)
{
  gt_assert(lb != NULL);
  if (lb->ulongbounds != NULL)
  {
    lb->ulongbounds[code]++;
  } else
  {
    gt_assert(lb->uintbounds[code] < (uint32_t) UINT_MAX);
    lb->uintbounds[code]++;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2c21fe
movq 0x379dd3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x253e3c(%rip), %rsi    # 0x516013
leaq 0x2aec0d(%rip), %rdx    # 0x570deb
leaq 0x2c7bf9(%rip), %rcx    # 0x589dde
leaq 0x2c7c0f(%rip), %r8     # 0x589dfb
movl $0x36, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c2200
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2c2228
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x2c228d
jmp 0x2c222a
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
jb 0x2c2275
movq 0x379d5c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x253dc5(%rip), %rsi    # 0x516013
leaq 0x2c7bb9(%rip), %rdx    # 0x589e0e
leaq 0x2c7b82(%rip), %rcx    # 0x589dde
leaq 0x2c7b98(%rip), %r8     # 0x589dfb
movl $0x3c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c2277
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_compareCodeatposition
static int dc_compareCodeatposition(const void *vala,const void *valb)
{
  const Codeatposition *a = (const Codeatposition *) vala;
  const Codeatposition *b = (const Codeatposition *) valb;

  if (a->maxprefixindex < b->maxprefixindex)
  {
    return -1;
  }
  if (a->maxprefixindex > b->maxprefixindex)
  {
    return 1;
  }
  if (a->position < b->position)
  {
    return 1;
  }
  if (a->position > b->position)
  {
    return -1;
  }
  gt_assert(false);
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
andl $0xf, %eax
movq (%rsp), %rcx
movl (%rcx), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
jge 0x2c22e5
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2c237a
movq 0x8(%rsp), %rax
movl (%rax), %eax
andl $0xf, %eax
movq (%rsp), %rcx
movl (%rcx), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
jle 0x2c2306
movl $0x1, 0x24(%rsp)
jmp 0x2c237a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x2c2323
movl $0x1, 0x24(%rsp)
jmp 0x2c237a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x2c2340
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2c237a
jmp 0x2c2342
movq 0x379c57(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x253cc0(%rip), %rsi    # 0x516013
leaq 0x296a09(%rip), %rdx    # 0x558d63
leaq 0x2c7ad8(%rip), %rcx    # 0x589e39
leaq 0x2c7453(%rip), %r8     # 0x5897bb
movl $0x28b, %r9d            # imm = 0x28B
movb $0x0, %al
callq 0x199f0
callq 0x19370
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/bcktab.h
// Function: gt_bcktab_leftborder_insertionindex
static inline GtUword gt_bcktab_leftborder_insertionindex(
                                                  GtLeftborder *lb,
                                                  GtCodetype code)
{
  gt_assert(lb != NULL);
  if (lb->ulongbounds != NULL)
  {
    return --lb->ulongbounds[code];
  }
  gt_assert(lb->uintbounds != NULL);
  return (GtUword) --lb->uintbounds[code];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2c283d
movq 0x379794(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2537fd(%rip), %rsi    # 0x516013
leaq 0x2ae5ce(%rip), %rdx    # 0x570deb
leaq 0x2c77ab(%rip), %rcx    # 0x589fcf
leaq 0x2c75d0(%rip), %r8     # 0x589dfb
movl $0x45, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c283f
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2c286b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rdx
movq (%rcx,%rdx,8), %rax
addq $-0x1, %rax
movq %rax, (%rcx,%rdx,8)
movq %rax, 0x10(%rsp)
jmp 0x2c28ce
jmp 0x2c286d
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x2c28b0
movq 0x379721(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25378a(%rip), %rsi    # 0x516013
leaq 0x2ae595(%rip), %rdx    # 0x570e25
leaq 0x2c7738(%rip), %rcx    # 0x589fcf
leaq 0x2c755d(%rip), %r8     # 0x589dfb
movl $0x4a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c28b2
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq (%rsp), %rdx
movl (%rcx,%rdx,4), %eax
addl $-0x1, %eax
movl %eax, (%rcx,%rdx,4)
movl %eax, %eax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_initinversesuftabnonspecialsadjust
static void dc_initinversesuftabnonspecialsadjust(GtDifferencecover *dcov)
{
  GtCodetype code;
  GtUword idx = 0;
  const GtCodetype mincode = 0;
  unsigned int rightchar = 0; /* as mincode is 0 */

  for (code = mincode; code <= dcov->maxcode; code++)
  {
    GtBucketspecification bucketspec;

    rightchar = gt_bcktab_calcboundsparts(&bucketspec,
                                          dcov->bcktab,
                                          code,
                                          dcov->maxcode,
                                          dcov->effectivesamplesize,
                                          rightchar);
    for (/* Nothing */; idx < bucketspec.left; idx++)
    {
      dc_inversesuftab_set(dcov,dc_suffixptrget(dcov,idx),idx);
    }
    dc_updatewidth (dcov,bucketspec.nonspecialsinbucket,dcov->prefixlength);
    for (/* Nothing */;
         idx < bucketspec.left + bucketspec.nonspecialsinbucket;
         idx++)
    {
      dc_inversesuftab_set(dcov,dc_suffixptrget(dcov,idx),
                           bucketspec.left);
    }
  }
  for (/* Nothing */; idx < dcov->effectivesamplesize; idx++)
  {
    dc_inversesuftab_set(dcov,dc_suffixptrget(dcov,idx),idx);
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rcx
cmpq 0xc0(%rcx), %rax
ja 0x2c2cab
movq 0x50(%rsp), %rax
movq 0x58(%rax), %rsi
movq 0x48(%rsp), %rdx
movq 0x50(%rsp), %rax
movq 0xc0(%rax), %rcx
movq 0x50(%rsp), %rax
movq 0x78(%rax), %r8
movl 0x34(%rsp), %r9d
leaq 0x18(%rsp), %rdi
callq 0x2058b0
movl %eax, 0x34(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x2c2c30
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2c40e0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rdx
callq 0x2c3f90
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x2c2be9
movq 0x50(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x50(%rsp), %rax
movl 0x18(%rax), %edx
callq 0x2c4120
movq 0x40(%rsp), %rax
movq 0x18(%rsp), %rcx
addq 0x20(%rsp), %rcx
cmpq %rcx, %rax
jae 0x2c2c96
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2c40e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
callq 0x2c3f90
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x2c2c47
jmp 0x2c2c98
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x2c2b9c
jmp 0x2c2cad
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x2c2cf6
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2c40e0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rdx
callq 0x2c3f90
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x2c2cad
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_bcktab2firstlevelintervals
static void dc_bcktab2firstlevelintervals(GtDifferencecover *dcov)
{
  GtCodetype code;
  unsigned int rightchar;
  const GtCodetype mincode = 0;

  gt_assert(dcov != NULL);
  gt_logger_log(dcov->logger,"maxbucketsize="GT_WU"",dcov->allocateditvinfo);
  rightchar = (unsigned int) (mincode % dcov->numofchars);
  for (code = 0; code <= dcov->maxcode; code++)
  {
    GtBucketspecification bucketspec;

    rightchar = gt_bcktab_calcboundsparts(&bucketspec,
                                          dcov->bcktab,
                                          code,
                                          dcov->maxcode,
                                          dcov->effectivesamplesize,
                                          rightchar);
    if (bucketspec.nonspecialsinbucket > 1UL)
    {
      dc_sortsuffixesonthislevel(dcov,
                                 bucketspec.left,
                                 bucketspec.nonspecialsinbucket);
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x2c2d52
movq 0x37927f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2532e8(%rip), %rsi    # 0x516013
leaq 0x2c6acf(%rip), %rdx    # 0x589801
leaq 0x2c7417(%rip), %rcx    # 0x58a150
leaq 0x2c6a7b(%rip), %r8     # 0x5897bb
movl $0x43d, %r9d            # imm = 0x43D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c2d54
movq 0x30(%rsp), %rax
movq 0x140(%rax), %rdi
movq 0x30(%rsp), %rax
movq 0xa0(%rax), %rdx
leaq 0x2b54ec(%rip), %rsi    # 0x57825f
movb $0x0, %al
callq 0xe7cd0
movq 0x30(%rsp), %rax
movl 0x14(%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x24(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0xc0(%rcx), %rax
ja 0x2c2e0e
movq 0x30(%rsp), %rax
movq 0x58(%rax), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rax
movq 0xc0(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x78(%rax), %r8
movl 0x24(%rsp), %r9d
movq %rsp, %rdi
callq 0x2058b0
movl %eax, 0x24(%rsp)
cmpq $0x1, 0x8(%rsp)
jbe 0x2c2dfc
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2c4260
jmp 0x2c2dfe
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2c2d9a
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_addunsortedrange
static void dc_addunsortedrange(void *voiddcov,
                                GT_UNUSED GtSuffixsortspace *sssp,
                                GtUword blisbl,
                                GtUword width,
                                GT_UNUSED GtUword depth)
{
  GtDifferencecover *dcov = (GtDifferencecover *) voiddcov;
  GtDcPairsuffixptr *ptr;

  gt_assert(depth >= (GtUword) dcov->vparam);
  dc_updatewidth (dcov,width,dcov->vparam);
  GT_GETNEXTFREEINARRAY(ptr,&dcov->firstgeneration,GtDcPairsuffixptr,1024);
  ptr->blisbl = blisbl;
  ptr->width = width;
}

// 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 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
cmpq %rcx, %rax
jae 0x2c3200
movq 0x378dd1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x252e3a(%rip), %rsi    # 0x516013
leaq 0x2c7167(%rip), %rdx    # 0x58a347
leaq 0x2c7180(%rip), %rcx    # 0x58a367
leaq 0x2c65cd(%rip), %r8     # 0x5897bb
movl $0x45c, %r9d            # imm = 0x45C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c3202
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rax
movl (%rax), %edx
callq 0x2c4120
jmp 0x2c321a
movq 0x18(%rsp), %rax
movq 0x120(%rax), %rax
addq $0x0, %rax
movq 0x18(%rsp), %rcx
cmpq 0x118(%rcx), %rax
jb 0x2c32dc
movq $0x400, 0x8(%rsp)       # imm = 0x400
xorl %eax, %eax
cmpq 0x8(%rsp), %rax
jbe 0x2c3286
movq 0x378d4b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x252db4(%rip), %rsi    # 0x516013
leaq 0x255f41(%rip), %rdx    # 0x5191a7
leaq 0x2c70fa(%rip), %rcx    # 0x58a367
leaq 0x2c6547(%rip), %r8     # 0x5897bb
movl $0x45e, %r9d            # imm = 0x45E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c3288
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
addq 0x118(%rax), %rcx
movq %rcx, 0x118(%rax)
movq 0x18(%rsp), %rax
movq 0x110(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rsi
shlq $0x4, %rsi
leaq 0x2c64f8(%rip), %rdx    # 0x5897bb
movl $0x45e, %ecx            # imm = 0x45E
callq 0xe8540
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x110(%rax)
jmp 0x2c32de
movq 0x18(%rsp), %rax
cmpq $0x0, 0x110(%rax)
jne 0x2c3325
movq 0x378cac(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x252d15(%rip), %rsi    # 0x516013
leaq 0x2c7076(%rip), %rdx    # 0x58a37b
leaq 0x2c705b(%rip), %rcx    # 0x58a367
leaq 0x2c64a8(%rip), %r8     # 0x5897bb
movl $0x45e, %r9d            # imm = 0x45E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c3327
jmp 0x2c3329
movq 0x18(%rsp), %rax
movq 0x110(%rax), %rax
movq 0x18(%rsp), %rdx
movq 0x120(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x120(%rdx)
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_verify_inversesuftab
static void dc_verify_inversesuftab(const GtDifferencecover *dcov)
{
  GtUword idx;

  for (idx=0; idx < dcov->effectivesamplesize; idx++)
  {
    GtUword idx2 = dc_inversesuftab_get(dcov,dc_suffixptrget(dcov,idx));
    if (idx != idx2)
    {
      fprintf(stderr,"idx = "GT_WU" != "GT_WU" = idx2\n",idx,idx2);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x2c375a
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2c40e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2c0130
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2c3745
movq 0x378880(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x2c6d45(%rip), %rsi    # 0x58a479
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
jmp 0x2c3747
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2c36d2
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_filldiff2pos
static void dc_filldiff2pos(GtDifferencecover *dcov)
{
  Diffvalue *iptr, *jptr;

  gt_assert(dcov->diff2pos == NULL);
  dcov->diff2pos = gt_malloc(sizeof (*dcov->diff2pos) * dcov->vparam);
  dcov->requiredspace += sizeof (*dcov->diff2pos) * dcov->vparam;
  for (iptr=dcov->diffvalues + dcov->size - 1; iptr>=dcov->diffvalues; iptr--)
  {
    for (jptr=dcov->diffvalues; jptr<dcov->diffvalues + dcov->size; jptr++)
    {
      dcov->diff2pos[GT_MODV(*jptr - *iptr)] = *iptr;
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x2c3c4d
movq 0x378384(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2523ed(%rip), %rsi    # 0x516013
leaq 0x2c6889(%rip), %rdx    # 0x58a4b6
leaq 0x2c6899(%rip), %rcx    # 0x58a4cd
leaq 0x2c5b80(%rip), %r8     # 0x5897bb
movl $0x168, %r9d            # imm = 0x168
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c3c4f
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %edi
shlq %rdi
leaq 0x2c5b59(%rip), %rsi    # 0x5897bb
movl $0x169, %edx            # imm = 0x169
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %ecx
shlq %rcx
movq 0x10(%rsp), %rax
addq 0x40(%rax), %rcx
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
movl 0x8(%rcx), %ecx
shlq %rcx
addq %rcx, %rax
addq $-0x2, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x2c3d45
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x10(%rsp), %rdx
movl 0x8(%rdx), %edx
shlq %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x2c3d30
movq 0x8(%rsp), %rax
movw (%rax), %dx
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq (%rsp), %rcx
movzwl (%rcx), %ecx
movq 0x8(%rsp), %rsi
movzwl (%rsi), %esi
subl %esi, %ecx
movq 0x10(%rsp), %rsi
andl 0xc(%rsi), %ecx
movl %ecx, %ecx
movw %dx, (%rax,%rcx,2)
movq (%rsp), %rax
addq $0x2, %rax
movq %rax, (%rsp)
jmp 0x2c3cd2
jmp 0x2c3d32
movq 0x8(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x8(%rsp)
jmp 0x2c3cb1
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_updatewidth
static void dc_updatewidth (GtDifferencecover *dcov,GtUword width,
                            unsigned int depth)
{
  if (width > 1UL)
  {
    gt_assert(dcov != NULL);
    dcov->firstgenerationtotalwidth += width;
    dcov->firstgenerationcount++;
    if (dcov->allocateditvinfo < width)
    {
      dcov->allocateditvinfo = width;
    }
    if (dcov->currentdepth == 0)
    {
      dcov->currentdepth = (GtUword) depth;
    } else
    {
      gt_assert(dcov->currentdepth == (GtUword) depth);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
cmpq $0x1, 0x8(%rsp)
jbe 0x2c424d
jmp 0x2c4140
cmpq $0x0, 0x10(%rsp)
jne 0x2c4180
movq 0x377e51(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x251eba(%rip), %rsi    # 0x516013
leaq 0x2c56a1(%rip), %rdx    # 0x589801
leaq 0x2c5fb4(%rip), %rcx    # 0x58a11b
leaq 0x2c564d(%rip), %r8     # 0x5897bb
movl $0x337, %r9d            # imm = 0x337
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c4182
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
addq 0x130(%rax), %rcx
movq %rcx, 0x130(%rax)
movq 0x10(%rsp), %rax
movq 0x138(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x138(%rax)
movq 0x10(%rsp), %rax
movq 0xa0(%rax), %rax
cmpq 0x8(%rsp), %rax
jae 0x2c41d5
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0xa0(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0xb8(%rax)
jne 0x2c41f8
movl 0x4(%rsp), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movq %rcx, 0xb8(%rax)
jmp 0x2c424b
jmp 0x2c41fa
movq 0x10(%rsp), %rax
movq 0xb8(%rax), %rax
movl 0x4(%rsp), %ecx
cmpq %rcx, %rax
je 0x2c4247
movq 0x377d8a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x251df3(%rip), %rsi    # 0x516013
leaq 0x2c5f03(%rip), %rdx    # 0x58a12a
leaq 0x2c5eed(%rip), %rcx    # 0x58a11b
leaq 0x2c5586(%rip), %r8     # 0x5897bb
movl $0x343, %r9d            # imm = 0x343
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c4249
jmp 0x2c424b
jmp 0x2c424d
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_compareitv
static int dc_compareitv(const void *a,const void *b)
{
  const GtDcItventry *itva = (const GtDcItventry *) a,
                     *itvb = (const GtDcItventry *) b;

  if (itva->key < itvb->key)
  {
    return -1;
  }
  if (itva->key > itvb->key)
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2c478a
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x2c47ae
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x2c47a6
movl $0x1, -0x4(%rsp)
jmp 0x2c47ae
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_showintervalsizes
static void dc_showintervalsizes(GtUword count,
                                 GtUword totalwidth,
                                 GtUword effectivesamplesize,
                                 GtUword maxwidth,
                                 GtUword depth,
                                 GtLogger *logger)
{
  gt_logger_log(logger,
              "level "GT_WU""
              ": (intervals="GT_WU",total="GT_WU","
              "avg=%.2f,%.2f%% of all,maxwidth="GT_WU")",
              depth,
              count,
              totalwidth,
              (double) totalwidth/count,
              100.0 * (double) totalwidth/effectivesamplesize,
              maxwidth);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq %r8, %xmm1
movaps 0x253d9e(%rip), %xmm4   # 0x518930
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
movapd 0x253da2(%rip), %xmm3   # 0x518940
subpd %xmm3, %xmm1
movaps %xmm1, %xmm0
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm0, %xmm1
movq %rcx, %xmm2
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subpd %xmm3, %xmm2
movaps %xmm2, %xmm0
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm0, %xmm2
movaps %xmm1, %xmm0
divsd %xmm2, %xmm0
movsd 0x255c64(%rip), %xmm2   # 0x51a838
mulsd %xmm2, %xmm1
movq 0x20(%rsp), %xmm2
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
divsd %xmm2, %xmm1
movq 0x18(%rsp), %r9
leaq 0x2c5676(%rip), %rsi    # 0x58a277
movb $0x2, %al
callq 0xe7cd0
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_inl_dc_queue_add
static void gt_inl_dc_queue_add(GtInlDCQueue *q, GtInlDCQueueelem elem,
                                    bool doublesize)
{
  gt_assert(q != NULL);
  if (q->noofelements == q->queuesize)
  {
    gt_inl_dc_queue_extend(q,doublesize);
  }
  q->noofelements++;
  q->queuespace[q->enqueueindex] = elem;
  if (q->enqueueindex > 0)
  {
    q->enqueueindex--;
  } else
  {
    q->enqueueindex = q->queuesize - 1; /* dequeuindex < queuesize-1 */
  }
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rsi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2c4c6b
movq 0x377366(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2513cf(%rip), %rsi    # 0x516013
leaq 0x2ca880(%rip), %rdx    # 0x58f4cb
leaq 0x2c566e(%rip), %rcx    # 0x58a2c0
leaq 0x2c4b62(%rip), %r8     # 0x5897bb
movl $0xce, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c4c6d
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x2c4c94
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x2c4d10
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x2c4ced
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x2c4d03
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
subq $0x1, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_initinversesuftabnonspecials
static void dc_initinversesuftabnonspecials(GtDifferencecover *dcov)
{
  GtUword sampleindex;

  gt_assert(dcov != NULL);
  for (sampleindex=0; sampleindex < dcov->effectivesamplesize; sampleindex++)
  {
    GtUword pos = dc_suffixptrget(dcov,sampleindex);
    dc_inversesuftab_set(dcov,pos,sampleindex);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2c5049
movq 0x376f88(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x250ff1(%rip), %rsi    # 0x516013
leaq 0x2c47d8(%rip), %rdx    # 0x589801
leaq 0x2c53fd(%rip), %rcx    # 0x58a42d
leaq 0x2c4784(%rip), %r8     # 0x5897bb
movl $0x2cc, %r9d            # imm = 0x2CC
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c504b
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x2c509a
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2c40e0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2c3f90
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2c5054
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_inl_dc_queue_get
static GtInlDCQueueelem gt_inl_dc_queue_get(GtInlDCQueue *q)
{
  GtInlDCQueueelem value;

  gt_assert(q != NULL && q->noofelements > 0);
  q->noofelements--;
  value = q->queuespace[q->dequeueindex];
  if (q->dequeueindex > 0)
  {
    q->dequeueindex--;
  } else
  {
    q->dequeueindex = q->queuesize - 1;  /* != enqueueindex, since at least
                                            one elem */
  }
  return value;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c512a
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
ja 0x2c5162
movq 0x376e6f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x250ed8(%rip), %rsi    # 0x516013
leaq 0x27deab(%rip), %rdx    # 0x542fed
leaq 0x2c531c(%rip), %rcx    # 0x58a465
leaq 0x2c466b(%rip), %r8     # 0x5897bb
movl $0xe7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c5164
movq (%rsp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq 0x10(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x2c51b8
movq (%rsp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x2c51cc
movq (%rsp), %rax
movq 0x18(%rax), %rcx
subq $0x1, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_qsortcmparr
static int QSORTNAME(qsortcmparr) (GtUword a,
                                   GtUword b,
                                   const GtDifferencecover *dcov,
                                   GtLcptrace *lcptrace,
                                   GtUword subbucketleft,
                                   const QSORTNAME(Datatype) sssp)
{
  GtUword suffixpos1, suffixpos2;

  gt_assert(sssp != NULL);
  suffixpos1 = dc_ARRAY_GET(sssp,a);
  suffixpos2 = dc_ARRAY_GET(sssp,b);
  return gt_differencecover_compare (dcov, lcptrace, suffixpos1, suffixpos2);
}

// 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)
cmpq $0x0, 0x18(%rsp)
jne 0x2c5282
movq 0x376d4f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x250db8(%rip), %rsi    # 0x516013
leaq 0x2c53d1(%rip), %rdx    # 0x58a633
leaq 0x2c53d7(%rip), %rcx    # 0x58a640
leaq 0x2c454b(%rip), %r8     # 0x5897bb
movl $0x797, %r9d            # imm = 0x797
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c5284
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x2e9ec0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x2e9ec0
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x2c55a0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: gt_differencecover_eval_lcp
static GtUword gt_differencecover_eval_lcp(const GtLcptrace *lcptrace,
                                           const GtDifferencecover *dcov)
{
  if (lcptrace->idx1 < dcov->effectivesamplesize &&
      lcptrace->idx2 < dcov->effectivesamplesize)
  {
    gt_assert(dcov->rmq != NULL);
    return (GtUword)
            gt_rmq_find_min_value(dcov->rmq,
                                  GT_MIN(lcptrace->idx1,lcptrace->idx2)+1,
                                  GT_MAX(lcptrace->idx1,lcptrace->idx2))
             + lcptrace->offset;
  }
  return (GtUword) lcptrace->offset;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x2c5410
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x78(%rcx), %rax
jae 0x2c5410
jmp 0x2c5320
movq 0x20(%rsp), %rax
cmpq $0x0, 0x150(%rax)
jne 0x2c5367
movq 0x376c6a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x250cd3(%rip), %rsi    # 0x516013
leaq 0x2c46fc(%rip), %rdx    # 0x589a43
leaq 0x2c537e(%rip), %rcx    # 0x58a6cc
leaq 0x2c4466(%rip), %r8     # 0x5897bb
movl $0x768, %r9d            # imm = 0x768
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c5369
movq 0x20(%rsp), %rax
movq 0x150(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x2c539e
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2c53ac
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x2c53dd
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x2c53ea
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq (%rsp), %rdx
callq 0x1cc2a0
movl %eax, %eax
movq 0x28(%rsp), %rcx
movl (%rcx), %ecx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x2c541c
movq 0x28(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-diffcov.c
// Function: dc_gt_inlined_qsort_arr_r_med3
static inline GtUword QSORTNAME(gt_inlined_qsort_arr_r_med3)
                     (GtUword a, GtUword b, GtUword c,
                      const GtDifferencecover *dcov,
                      GtLcptrace *lcptrace,
                      GtUword subbucketleft,
                      const QSORTNAME(Datatype) data)
{
  return
    QSORTNAME(qsortcmparr) (a, b, dcov, lcptrace, subbucketleft, data) < 0
      ? (QSORTNAME(qsortcmparr) (b, c, dcov, lcptrace,
                                 subbucketleft, data) < 0
        ? b
        : (QSORTNAME(qsortcmparr) (a, c, dcov, lcptrace,
                                   subbucketleft, data) < 0
          ? c : a))
          : (QSORTNAME(qsortcmparr) (b, c, dcov, lcptrace,
                                     subbucketleft, data) > 0
            ? b
            : (QSORTNAME(qsortcmparr) (a, c, dcov, lcptrace,
                                       subbucketleft, data) < 0
              ? a
              : c));
}

// Assembly:
subq $0x58, %rsp
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x60(%rsp), %r9
callq 0x2c5220
cmpl $0x0, %eax
jge 0x2c550e
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x60(%rsp), %r9
callq 0x2c5220
cmpl $0x0, %eax
jge 0x2c54b7
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2c54ff
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x60(%rsp), %r9
callq 0x2c5220
cmpl $0x0, %eax
jge 0x2c54eb
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x2c54f5
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x2c5591
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x60(%rsp), %r9
callq 0x2c5220
cmpl $0x0, %eax
jle 0x2c5542
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x2c5587
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x60(%rsp), %r9
callq 0x2c5220
cmpl $0x0, %eax
jge 0x2c5575
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
jmp 0x2c557e
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)