LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-lcpvalues.h
// Function: gt_lcptab_getvalue
static inline GtUword gt_lcptab_getvalue(
                                        const GtLcpvalues *tableoflcpvalues,
                                        GtUword subbucketleft,
                                        GtUword idx)
{
  gt_assert (tableoflcpvalues != NULL &&
             tableoflcpvalues->bucketoflcpvalues != NULL &&
             tableoflcpvalues->lcptaboffset+subbucketleft+idx <
             tableoflcpvalues->numofentries);
  gt_assert(tableoflcpvalues->isset == NULL ||
            GT_ISIBITSET(tableoflcpvalues->isset,
                         tableoflcpvalues->lcptaboffset+subbucketleft+idx));
  return (GtUword) tableoflcpvalues->bucketoflcpvalues
                           [tableoflcpvalues->lcptaboffset+subbucketleft+idx];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2b6883
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2b6883
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
addq 0x8(%rsp), %rax
addq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2b68bb
movq 0x385716(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25f77f(%rip), %rsi    # 0x516013
leaq 0x2d1e55(%rip), %rdx    # 0x5886f0
leaq 0x2d1eeb(%rip), %rcx    # 0x58878d
leaq 0x2d1ef7(%rip), %r8     # 0x5887a0
movl $0x5b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b68bd
jmp 0x2b68bf
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2b6957
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
addq 0x8(%rsp), %rcx
addq (%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
addq 0x8(%rsp), %rcx
addq (%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x2b6957
movq 0x38567a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25f6e3(%rip), %rsi    # 0x516013
leaq 0x2d1e83(%rip), %rdx    # 0x5887ba
leaq 0x2d1e4f(%rip), %rcx    # 0x58878d
leaq 0x2d1e5b(%rip), %r8     # 0x5887a0
movl $0x5e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b6959
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x20(%rcx), %rcx
addq 0x8(%rsp), %rcx
addq (%rsp), %rcx
movl (%rax,%rcx,4), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: realmedian
static GtUword realmedian(const GtBentsedgresources *bsr,
                                GtUword subbucketleft,
                                GtUword width,
                                GtUword depth)
{
  GtMedianinfo *medianptr;
  GtUword idx;

  for (idx = 0; idx < width; idx++)
  {
    bsr->medianinfospace[idx].suftaboffset = idx;
    PTR2INT(bsr->medianinfospace[idx].etbe,subbucketleft,idx);
  }
  medianptr = quickmedian(bsr->fwd,bsr->complement,bsr->medianinfospace,width);
/*
  checkmedian(bsr->fwd,bsr->complement,medianptr,medianinfospace,width);
*/
  gt_assert(medianptr != NULL);
  return medianptr->suftaboffset;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2b71d1
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x2d0(%rax), %rax
movq 0x8(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x2e9ec0
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x2d0(%rax), %rax
movq 0x8(%rsp), %rdx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
addq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0xb0(%rcx), %rax
jae 0x2b717e
movq 0x18(%rsp), %rax
addq (%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x2d0(%rax), %rdi
movq 0x8(%rsp), %rax
shlq $0x5, %rax
addq %rax, %rdi
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x30(%rsp), %rax
movq (%rax), %rdx
movq 0x30(%rsp), %rax
movl 0x18(%rax), %ecx
movq (%rsp), %r8
callq 0xb34d0
jmp 0x2b71bc
movq 0x30(%rsp), %rax
movq 0x2d0(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq 0x30(%rsp), %rax
movq 0x2d0(%rax), %rax
movq 0x8(%rsp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
jmp 0x2b71be
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2b70b1
movq 0x30(%rsp), %rax
movb 0x1c(%rax), %sil
movq 0x30(%rsp), %rax
movb 0x1d(%rax), %al
movq 0x30(%rsp), %rcx
movq 0x2d0(%rcx), %rdx
movq 0x20(%rsp), %rcx
andb $0x1, %sil
andb $0x1, %al
movzbl %sil, %edi
movzbl %al, %esi
callq 0x2b7260
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2b724a
movq 0x384d87(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25edf0(%rip), %rsi    # 0x516013
leaq 0x2d1651(%rip), %rdx    # 0x58887b
leaq 0x2c3ee6(%rip), %rcx    # 0x57b117
leaq 0x2d1338(%rip), %r8     # 0x588570
movl $0x2d1, %r9d            # imm = 0x2D1
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b724c
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_bs_priority_queue_new
static GtBentsedgePrioqueue *gt_bs_priority_queue_new(GtUword numofelements)
{
  GtBentsedgePrioqueue *pq = gt_malloc(sizeof *pq);

  pq->elements = gt_malloc(sizeof (*pq->elements) * numofelements);
  pq->capacity = numofelements;
  pq->numofelements = 0;
  return pq;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x18, %edi
leaq 0x2d0b5b(%rip), %rsi    # 0x588570
movl $0x72a, %edx            # imm = 0x72A
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
shlq $0x3, %rdi
leaq 0x2d0b3c(%rip), %rsi    # 0x588570
movl $0x72c, %edx            # imm = 0x72C
callq 0xe80f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_BentsedgIterator_next
static bool gt_BentsedgIterator_next(GtBucketspecification *bucketspec,
                                     GtBentsedgIterator *bs_it)
{
  if (bs_it->code <= bs_it->maxcode)
  {
    bs_it->rightchar = gt_bcktab_calcboundsparts(bucketspec,
                                                 bs_it->bcktab,
                                                 bs_it->code,
                                                 bs_it->maxcode,
                                                 bs_it->totalwidth,
                                                 bs_it->rightchar);
    bs_it->code++;
    return true;
  } else
  {
    return false;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rsp), %rcx
cmpq 0x28(%rcx), %rax
ja 0x2b7ae0
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
movq (%rsp), %rax
movq 0x18(%rax), %rdx
movq (%rsp), %rax
movq 0x28(%rax), %rcx
movq (%rsp), %rax
movq (%rax), %r8
movq (%rsp), %rax
movl 0x30(%rax), %r9d
callq 0x2058b0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x30(%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movb $0x1, 0x17(%rsp)
jmp 0x2b7ae5
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_bendsedgSynchronizer_process
static void gt_bendsedgSynchronizer_process(GtBentsedgSynchronizer *bs_sync,
                                            GtUword bucketnumber)
{
  gt_assert(bs_sync != NULL);
  if (bs_sync->nextrequest == bucketnumber)
  {
    bs_sync->nextrequest++;
    while (!gt_bs_priority_queue_is_empty(bs_sync->queue) &&
           gt_bs_priority_queue_min_bucketnumber(bs_sync->queue) ==
           bs_sync->nextrequest)
    {
      gt_bs_priority_queue_delete_min(bs_sync->queue);
      bs_sync->nextrequest++;
    }
  } else
  {
    GtPriorecord priorecord;
    gt_assert(bs_sync->nextrequest < bucketnumber);
    priorecord.bucketnumber = bucketnumber;
    gt_bs_priority_queue_add(bs_sync->queue,priorecord);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2b7b3e
movq 0x384493(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25e4fc(%rip), %rsi    # 0x516013
leaq 0x2d0ee7(%rip), %rdx    # 0x588a05
leaq 0x2d0ef0(%rip), %rcx    # 0x588a15
leaq 0x2d0a44(%rip), %r8     # 0x588570
movl $0x77b, %r9d            # imm = 0x77B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b7b40
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0x2b7bc4
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x2b3d50
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x2b7b98
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x2b3ce0
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2b7ba2
jmp 0x2b7bc2
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x2b7c40
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
jmp 0x2b7b61
jmp 0x2b7c2c
jmp 0x2b7bc6
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
cmpq 0x18(%rsp), %rax
jb 0x2b7c0e
movq 0x3843c3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25e42c(%rip), %rsi    # 0x516013
leaq 0x2d0e47(%rip), %rdx    # 0x588a35
leaq 0x2d0e20(%rip), %rcx    # 0x588a15
leaq 0x2d0974(%rip), %r8     # 0x588570
movl $0x789, %r9d            # imm = 0x789
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b7c10
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x2b7cb0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bentsedg.c
// Function: gt_bs_priority_queue_add
static void gt_bs_priority_queue_add(GtBentsedgePrioqueue *pq,
                                     GtPriorecord priorecord)
{
  GtPriorecord *ptr;

  gt_assert(pq != NULL);
  if (pq->numofelements >= pq->capacity)
  {
    pq->capacity *= 2;
    pq->elements = gt_realloc(pq->elements,sizeof *pq->elements * pq->capacity);
  }
  /* store elements in reverse order, i.e.\ with the minimum element
     at the last index; shift elements to the right until an element larger
     or equal than the key is found. */
  for (ptr = pq->elements + pq->numofelements;
       ptr > pq->elements && (ptr-1)->bucketnumber < priorecord.bucketnumber;
       ptr--)
  {
    *ptr = *(ptr-1);
  }
  pq->numofelements++;
  gt_assert(ptr >= pq->elements && ptr < pq->elements + pq->numofelements);
  *ptr = priorecord;
}

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2b7cfe
movq 0x3842d3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25e33c(%rip), %rsi    # 0x516013
leaq 0x2a8cb4(%rip), %rdx    # 0x560992
leaq 0x2d0d94(%rip), %rcx    # 0x588a79
leaq 0x2d0884(%rip), %r8     # 0x588570
movl $0x73d, %r9d            # imm = 0x73D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b7d00
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x2b7d53
movq 0x18(%rsp), %rax
movq (%rax), %rcx
shlq %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
shlq $0x3, %rsi
leaq 0x2d0833(%rip), %rdx    # 0x588570
movl $0x741, %ecx            # imm = 0x741
callq 0xe8540
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, 0xf(%rsp)
jbe 0x2b7d9c
movq 0x10(%rsp), %rax
movq -0x8(%rax), %rax
cmpq 0x20(%rsp), %rax
setb %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x2b7da6
jmp 0x2b7dc7
movq 0x10(%rsp), %rax
movq 0x10(%rsp), %rcx
movq -0x8(%rcx), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x2b7d71
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2b7e0b
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x18(%rsp), %rdx
movq 0x8(%rdx), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jb 0x2b7e43
movq 0x38418e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25e1f7(%rip), %rsi    # 0x516013
leaq 0x2d0c6f(%rip), %rdx    # 0x588a92
leaq 0x2d0c4f(%rip), %rcx    # 0x588a79
leaq 0x2d073f(%rip), %r8     # 0x588570
movl $0x74d, %r9d            # imm = 0x74D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b7e45
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: gt_blindtrie_resize
void gt_blindtrie_resize(GtBlindtrie *blindtrie,unsigned int maxnumofnodes)
{
  gt_assert(maxnumofnodes > 0);
  if (blindtrie->allocatedBlindtrienode > maxnumofnodes)
  {
    blindtrie->allocatedBlindtrienode = maxnumofnodes;
    blindtrie->spaceBlindtrienode
      = gt_realloc(blindtrie->spaceBlindtrienode,
                   sizeof (*blindtrie->spaceBlindtrienode) *
                   blindtrie->allocatedBlindtrienode);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
ja 0x2b818c
movq 0x383e45(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25deae(%rip), %rsi    # 0x516013
leaq 0x2d0a5d(%rip), %rdx    # 0x588bc9
leaq 0x2d0a68(%rip), %rcx    # 0x588bdb
leaq 0x2d09f9(%rip), %r8     # 0x588b73
movl $0x3bb, %r9d            # imm = 0x3BB
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b818e
movq 0x10(%rsp), %rax
movl (%rax), %eax
cmpl 0xc(%rsp), %eax
jbe 0x2b81d7
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
imulq $0x18, %rax, %rsi
leaq 0x2d09b2(%rip), %rdx    # 0x588b73
movl $0x3c2, %ecx            # imm = 0x3C2
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: gt_blindtrie_size
size_t gt_blindtrie_size(GtUword maxnumofsuffixes)
{
  if (maxnumofsuffixes == 1UL)
  {
    return 0;
  } else
  {
    return sizeof (GtBlindtrie) +
           (GT_MULT2(maxnumofsuffixes + 1) + 1) * sizeof (GtBlindtrienode);
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x1, -0x10(%rsp)
jne 0x2b81f8
movq $0x0, -0x8(%rsp)
jmp 0x2b8217
movq -0x10(%rsp), %rax
addq $0x1, %rax
shlq %rax
addq $0x1, %rax
imulq $0x18, %rax, %rax
addq $0x98, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: gt_blindtrie_delete
void gt_blindtrie_delete(GtBlindtrie *blindtrie)
{
  if (blindtrie == NULL)
  {
    return;
  }
  gt_Viatwobitkeyvalues_delete(blindtrie->vtk1);
  gt_Viatwobitkeyvalues_delete(blindtrie->vtk2);
  gt_free(blindtrie->spaceBlindtrienode);
  GT_FREEARRAY(&blindtrie->overflowsuffixes, GtUword);
  GT_FREEARRAY(&blindtrie->stack, GtBlindtriesnodeptr);
  gt_free(blindtrie);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2b8271
jmp 0x2b8355
movq (%rsp), %rax
movq 0x80(%rax), %rdi
callq 0xb4da0
movq (%rsp), %rax
movq 0x88(%rax), %rdi
callq 0xb4da0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x2d08d3(%rip), %rsi    # 0x588b73
movl $0x3e6, %edx            # imm = 0x3E6
callq 0xe88c0
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2b82f2
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x2d08af(%rip), %rsi    # 0x588b73
movl $0x3e7, %edx            # imm = 0x3E7
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
jmp 0x2b82f4
jmp 0x2b82f6
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2b833e
movq (%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x2d0863(%rip), %rsi    # 0x588b73
movl $0x3e8, %edx            # imm = 0x3E8
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0x2b8340
movq (%rsp), %rdi
leaq 0x2d0828(%rip), %rsi    # 0x588b73
movl $0x3e9, %edx            # imm = 0x3E9
callq 0xe88c0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: gt_blindtrie_suffixsort
void gt_blindtrie_suffixsort(GtBlindtrie *blindtrie,
                             GtUword subbucketleft,
                             GtLcpvalues *tableoflcpvalues,
                             GtUword numberofsuffixes,
                             GtUword offset,
                             GtUword sortmaxdepth,
                             GtProcessunsortedsuffixrange
                               processunsortedsuffixrange,
                             void *processunsortedsuffixrangeinfo)
{
  GtUword idx, currentstartpos;

  gt_blindtrie_reset(blindtrie);
  for (idx=0; idx < numberofsuffixes; idx++)
  {
    currentstartpos = gt_suffixsortspace_get(blindtrie->sssp,subbucketleft,idx);
    gt_blindtrie_insertsuffix(blindtrie,
                              offset,
                              sortmaxdepth,
                              currentstartpos + offset);
#ifdef SKDEBUG
    blindtrie_showstate(blindtrie,
                        subbucketleft,
                        idx+1,
                        offset);
#endif
  }
  gt_blindtrie2sorting(blindtrie,
                       subbucketleft,
                       tableoflcpvalues,
                       offset,
                       sortmaxdepth,
                       processunsortedsuffixrange,
                       processunsortedsuffixrangeinfo);
}

// Assembly:
subq $0x48, %rsp
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
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 0x2b8240
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2b83f9
movq 0x40(%rsp), %rax
movq 0x90(%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x2e9ec0
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
addq 0x20(%rsp), %rcx
callq 0x2b8430
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2b839f
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x50(%rsp), %r9
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
callq 0x2b8730
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: gt_blindtrie2sorting
static void gt_blindtrie2sorting(GtBlindtrie *blindtrie,
                                 GtUword subbucketleft,
                                 GtLcpvalues *tableoflcpvalues,
                                 GtUword offset,
                                 GtUword sortmaxdepth,
                                 GtProcessunsortedsuffixrange
                                   processunsortedsuffixrange,
                                 void *processunsortedsuffixrangeinfo)
{
  GtUword nextsuffixtosort
    = blindtrie_enumeratetrieleaves (blindtrie,subbucketleft,offset,
                                     sortmaxdepth,tableoflcpvalues,
                                     processunsortedsuffixrange,
                                     processunsortedsuffixrangeinfo);
  processoverflowsuffixes(blindtrie,
                          offset,
                          tableoflcpvalues,
                          subbucketleft,
                          nextsuffixtosort);
}

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
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
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x2b9750
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x2b9e70
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_currenttwobitencodingstoppos_get
static GtUword blindtrie_currenttwobitencodingstoppos_get(
                                     const GtBlindtrie *blindtrie,
                                     GtUword currentstartpos)
{
  if (!blindtrie->cmpcharbychar &&
      blindtrie->has_twobitencoding_stoppos_support)
  {
    gt_encseq_reader_reinit_with_readmode(blindtrie->esr1,blindtrie->encseq,
                                          blindtrie->readmode,
                                          currentstartpos);
    return gt_getnexttwobitencodingstoppos(GT_ISDIRREVERSE(blindtrie->readmode)
                                           ? false : true,blindtrie->esr1);
  }
  return GT_BLTRIESTOPPOSUNDEF(blindtrie);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x78(%rax)
jne 0x2b8bff
movq 0x18(%rsp), %rax
testb $0x1, 0x7a(%rax)
je 0x2b8bff
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x18(%rsp), %rax
movl 0x58(%rax), %edx
movq 0x10(%rsp), %rcx
callq 0xabdb0
movq 0x18(%rsp), %rcx
movb $0x1, %al
cmpl $0x1, 0x58(%rcx)
movb %al, 0xf(%rsp)
je 0x2b8bcd
movq 0x18(%rsp), %rax
cmpl $0x3, 0x58(%rax)
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
movq 0x18(%rsp), %rcx
movq 0x48(%rcx), %rsi
movzbl %al, %edi
andl $0x1, %edi
callq 0xb3180
movq %rax, 0x20(%rsp)
jmp 0x2b8c0d
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_getlcp
static GtUword blindtrie_getlcp(GtBlindtriesymbol *mm_oldsuffix,
                                      bool *mm_oldsuffixisseparator,
                                      GtBlindtriesymbol *mm_newsuffix,
                                      const GtBlindtrie *blindtrie,
                                      const GtBlindtriesnodeptr lis,
                                      GtUword currentstartpos,
                                      GtUword
                                        currenttwobitencodingstoppos)
{
  if (blindtrie->cmpcharbychar)
  {
    return blindtrie_cmpcharbychar_getlcp (mm_oldsuffix,
                                           mm_oldsuffixisseparator,
                                           mm_newsuffix,
                                           blindtrie,
                                           blindtrie_nodestartpos_get(blindtrie,
                                                                      lis),
                                           currentstartpos);
  }
  return blindtrie_twobitencoding_getlcp(mm_oldsuffix,
                                         mm_oldsuffixisseparator,
                                         mm_newsuffix,
                                         blindtrie,
                                         blindtrie_nodestartpos_get(blindtrie,
                                                                    lis),
                                         blindtrie_nodestoppos_get(blindtrie,
                                                                   lis),
                                         currentstartpos,
                                         currenttwobitencodingstoppos);
}

// Assembly:
subq $0x98, %rsp
movq 0xa0(%rsp), %rax
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movq %r9, 0x60(%rsp)
movq 0x70(%rsp), %rax
testb $0x1, 0x78(%rax)
je 0x2b91b8
movq 0x88(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movl 0x6c(%rsp), %esi
callq 0x2ba220
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq %rax, %r8
movq 0x60(%rsp), %r9
callq 0x2bac90
movq %rax, 0x90(%rsp)
jmp 0x2b9246
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
movl 0x6c(%rsp), %esi
callq 0x2ba220
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rdi
movl 0x6c(%rsp), %esi
callq 0x2bb1a0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movq %rax, %r9
movq 0x60(%rsp), %r10
movq 0xa0(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x2baef0
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_findsplitnode
static GtBlindtriesnodeptr blindtrie_findsplitnode(const GtBlindtrie *blindtrie,
                                                GtUword lcp)
{
  GtBlindtriesnodeptr currentnode;
  GtUword stackidx;

  currentnode = GT_BLINDTRIE_ROOTIDX;
  for (stackidx=0;stackidx<blindtrie->stack.nextfreeGtBlindtriesnodeptr;
       stackidx++)
  {
    currentnode = blindtrie->stack.spaceGtBlindtriesnodeptr[stackidx];
    if (blindtrie_isleaf(blindtrie,currentnode) ||
        blindtrie_getdepth(blindtrie,currentnode) >= lcp)
    {
      break;
    }
  }
  return currentnode;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x20(%rcx), %rax
jae 0x2b92df
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2b9080
testb $0x1, %al
jne 0x2b92cb
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2b9fe0
cmpq 0x18(%rsp), %rax
jb 0x2b92cd
jmp 0x2b92df
jmp 0x2b92cf
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2b927f
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_isleftofboundary
static bool blindtrie_isleftofboundary(const GtBlindtrie *blindtrie,
                                       GtUword currentstartpos,
                                       GtUword add)
{
  GtUword endpos;

  if (blindtrie->sortmaxdepthminusoffset == 0)
  {
    endpos = blindtrie->totallength;
  } else
  {
    endpos = currentstartpos + blindtrie->sortmaxdepthminusoffset;
    if (endpos >= blindtrie->totallength)
    {
      endpos = blindtrie->totallength;
    }
  }
  return (currentstartpos + add < endpos) ? true : false;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x70(%rax)
jne 0x2b96eb
movq -0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x2b971e
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
addq 0x70(%rcx), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x60(%rcx), %rax
jb 0x2b971c
movq -0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x2b971e
movq -0x10(%rsp), %rdx
addq -0x18(%rsp), %rdx
movq -0x20(%rsp), %rsi
xorl %eax, %eax
movl $0x1, %ecx
cmpq %rsi, %rdx
cmovbl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: processoverflowsuffixes
static void processoverflowsuffixes(GtBlindtrie *blindtrie,
                                    GtUword offset,
                                    GtLcpvalues *tableoflcpvalues,
                                    GtUword subbucketleft,
                                    GtUword nextsuffixtooutput)
{
  if (blindtrie->overflowsuffixes.nextfreeGtUword > 0)
  {
    GtUword idx;

    if (blindtrie->overflowsuffixes.nextfreeGtUword > 1UL)
    {
      qsort(blindtrie->overflowsuffixes.spaceGtUword,
            (size_t) blindtrie->overflowsuffixes.nextfreeGtUword,
            sizeof (*blindtrie->overflowsuffixes.spaceGtUword),
            blindtrie_compare_ascending);
    }
    for (idx = 0; idx < blindtrie->overflowsuffixes.nextfreeGtUword; idx++)
    {
      if (tableoflcpvalues != NULL)
      {
        gt_lcptab_update(tableoflcpvalues,subbucketleft,nextsuffixtooutput,
                         offset);
      }
      blindtrie_suffixout(blindtrie,subbucketleft,offset,nextsuffixtooutput,
                          blindtrie->overflowsuffixes.spaceGtUword[idx]);
      nextsuffixtooutput++;
    }
  }
}

// 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 0x30(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jbe 0x2b9f51
movq 0x30(%rsp), %rax
cmpq $0x1, 0x38(%rax)
jbe 0x2b9ecc
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rsp), %rax
movq 0x38(%rax), %rsi
movl $0x8, %edx
leaq 0x459(%rip), %rcx       # 0x2ba320
callq 0x19e70
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x2b9f4f
cmpq $0x0, 0x20(%rsp)
je 0x2b9f06
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x2ba060
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rsp), %r8
movq (%rax,%r8,8), %r8
callq 0x2ba1d0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x2b9ed5
jmp 0x2b9f51
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_compare_ascending
static int blindtrie_compare_ascending(const void *a,const void *b)
{
  GtUword *aptr = (GtUword *) a;
  GtUword *bptr = (GtUword *) b;
  gt_assert(*aptr != *bptr);
  return *aptr < *bptr ? -1 : 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x2ba38c
movq 0x381c45(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25bcae(%rip), %rsi    # 0x516013
leaq 0x2cea84(%rip), %rdx    # 0x588df0
leaq 0x2cea8c(%rip), %rcx    # 0x588dff
leaq 0x2ce7f9(%rip), %r8     # 0x588b73
movl $0x487, %r9d            # imm = 0x487
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ba38e
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rsi, %rdx
cmovbl %ecx, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_newnode
static GtBlindtriesnodeptr blindtrie_newnode(GtBlindtrie *blindtrie)
{
  if (blindtrie->nextfreeBlindtrienode >= blindtrie->allocatedBlindtrienode)
  {
    gt_assert(blindtrie->nodenumberincrement >= 1U);
    gt_assert(blindtrie->allocatedBlindtrienode +
              blindtrie->nodenumberincrement <=
              (1U << GT_BLINDTRIE_BITSFORRIGHTSIBLING) - 1);
    blindtrie->allocatedBlindtrienode += blindtrie->nodenumberincrement;
    blindtrie->spaceBlindtrienode
      = gt_realloc(blindtrie->spaceBlindtrienode,
                   sizeof (*blindtrie->spaceBlindtrienode) *
                          blindtrie->allocatedBlindtrienode);
  }
  return blindtrie->nextfreeBlindtrienode++;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x4(%rax), %eax
movq (%rsp), %rcx
cmpl (%rcx), %eax
jb 0x2ba4ab
jmp 0x2ba3da
movq (%rsp), %rax
cmpl $0x1, 0x7c(%rax)
jae 0x2ba41c
movq 0x381bb5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25bc1e(%rip), %rsi    # 0x516013
leaq 0x2cea6b(%rip), %rdx    # 0x588e67
leaq 0x2cea89(%rip), %rcx    # 0x588e8c
leaq 0x2ce769(%rip), %r8     # 0x588b73
movl $0x140, %r9d            # imm = 0x140
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ba41e
jmp 0x2ba420
movq (%rsp), %rax
movl (%rax), %eax
movq (%rsp), %rcx
addl 0x7c(%rcx), %eax
cmpl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jbe 0x2ba46c
movq 0x381b65(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25bbce(%rip), %rsi    # 0x516013
leaq 0x2cea52(%rip), %rdx    # 0x588e9e
leaq 0x2cea39(%rip), %rcx    # 0x588e8c
leaq 0x2ce719(%rip), %r8     # 0x588b73
movl $0x143, %r9d            # imm = 0x143
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ba46e
movq (%rsp), %rax
movl 0x7c(%rax), %ecx
movq (%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rsp), %rax
movl (%rax), %eax
imulq $0x18, %rax, %rsi
leaq 0x2ce6dd(%rip), %rdx    # 0x588b73
movl $0x148, %ecx            # imm = 0x148
callq 0xe8540
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movl 0x4(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x4(%rcx)
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_newleaf
static GtBlindtriesnodeptr blindtrie_newleaf(GtBlindtrie *blindtrie,
                                          GtUword currentstartpos,
                                          GtUword
                                            currenttwobitencodingstoppos,
                                          GtBlindtriesymbol firstchar,
                                          GtBlindtriesnodeptr rightsibling)
{
  GtBlindtriesnodeptr newleaf;

  newleaf = blindtrie_newnode(blindtrie);
  blindtrie_firstchar_set(blindtrie,newleaf,true,firstchar);
  blindtrie_leafinfo_set(blindtrie,
                         newleaf,
                         currentstartpos,
                         currenttwobitencodingstoppos);
  blindtrie_rightsibling_set(blindtrie,newleaf,rightsibling);
  return newleaf;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2ba3c0
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
movl (%rsp), %esi
movq 0x8(%rsp), %rcx
movl $0x1, %edx
callq 0x2ba4c0
movq 0x20(%rsp), %rdi
movl (%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x2ba780
movq 0x20(%rsp), %rdi
movl (%rsp), %esi
movl 0x4(%rsp), %edx
callq 0x2baa10
movl (%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_extractleafnode
static GtBlindtriesnodeptr blindtrie_extractleafnode(GtBlindtrie *blindtrie,
                                                     GtBlindtriesnodeptr head)
{
  gt_assert(!blindtrie_isleaf(blindtrie,head));
  do
  {
    head = blindtrie_firstchild_get(blindtrie,head);
  } while (!blindtrie_isleaf(blindtrie,head));
  return head;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x2b9080
testb $0x1, %al
jne 0x2baac1
jmp 0x2baaf9
movq 0x3814d8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25b541(%rip), %rsi    # 0x516013
leaq 0x2ce5c8(%rip), %rdx    # 0x5890a1
leaq 0x2ce5e3(%rip), %rcx    # 0x5890c3
leaq 0x2ce08c(%rip), %r8     # 0x588b73
movl $0x19a, %r9d            # imm = 0x19A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2baafb
jmp 0x2baafd
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x2b9f60
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x2b9080
xorb $-0x1, %al
testb $0x1, %al
jne 0x2baafd
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_findsucc
static GtBlindtriesnodeptr blindtrie_findsucc(const GtBlindtrie *blindtrie,
                                           GtBlindtriesnodeptr node,
                                           GtBlindtriesymbol newchar)
{
  int retval;

  for (;;)
  {
    retval = blindtrie_comparecharacters(
                     blindtrie_firstchar_get(blindtrie,node),
                     newchar);
    if (retval == 0)
    {              /* found branch corresponding to newchar */
      return node;
    }
    if (retval == 1)
    {               /* found sibling which is already greater than newchar */
      return GT_BLINDTRIE_REFNULL;
    }
    node = blindtrie_rightsibling_get(blindtrie,node);
    if (node == GT_BLINDTRIE_REFNULL) /* no more siblings: mismatch */
    {
      return GT_BLINDTRIE_REFNULL;
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2bac10
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x2babc0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x2bab72
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2baba8
cmpl $0x1, 0x4(%rsp)
jne 0x2bab83
movl $0x0, 0x24(%rsp)
jmp 0x2baba8
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x2ba2a0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0x2baba6
movl $0x0, 0x24(%rsp)
jmp 0x2baba8
jmp 0x2bab42
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-bltrie.c
// Function: blindtrie_copy_either
static void blindtrie_copy_either(GtBlindtrie *blindtrie,
                                  GtBlindtriesnodeptr destnode,
                                  GtBlindtriesnodeptr srcnode)
{
  gt_assert(destnode < blindtrie->nextfreeBlindtrienode &&
            srcnode < blindtrie->nextfreeBlindtrienode);
  blindtrie->spaceBlindtrienode[destnode].either1
    = blindtrie->spaceBlindtrienode[srcnode].either1;
  blindtrie->spaceBlindtrienode[destnode].either2
    = blindtrie->spaceBlindtrienode[srcnode].either2;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x2bb36d
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jb 0x2bb3a5
movq 0x380c2c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25ac95(%rip), %rsi    # 0x516013
leaq 0x2cdff2(%rip), %rdx    # 0x589377
leaq 0x2ce045(%rip), %rcx    # 0x5893d1
leaq 0x2cd7e0(%rip), %r8     # 0x588b73
movl $0x121, %r9d            # imm = 0x121
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2bb3a7
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movl 0x8(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl 0xc(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movl 0x8(%rsp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-copysort.c
// Function: fill2subbuckets
static void fill2subbuckets(GtBucketspec2 *bucketspec2,const GtBcktab *bcktab)
{
  GtCodetype code, maxcode;
  unsigned int rightchar = 0, currentchar = 0;
  GtBucketspecification bucketspec;
  GtUword accubucketsize = 0;

  maxcode = gt_bcktab_numofallcodes(bcktab) - 1;
  for (code = 0; code <= maxcode; code++)
  {
    rightchar = gt_bcktab_calcboundsparts(&bucketspec,
                                          bcktab,
                                          code,
                                          maxcode,
                                          bucketspec2->partwidth,
                                          rightchar);
    accubucketsize += bucketspec.nonspecialsinbucket;
    if (rightchar == 0)
    {
      bucketspec2->subbuckettab[currentchar]
                               [bucketspec2->numofchars-1].bucketend
        = accubucketsize;
      accubucketsize += bucketspec.specialsinbucket;
      bucketspec2->superbuckettab[currentchar].bucketend = accubucketsize;
      currentchar++;
    } else
    {
      gt_assert(bucketspec.specialsinbucket == 0);
      bucketspec2->subbuckettab[currentchar]
                               [rightchar-1].bucketend = accubucketsize;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq $0x0, (%rsp)
movq 0x38(%rsp), %rdi
callq 0x206600
subq $0x1, %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
ja 0x2bb805
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rax
movq (%rax), %r8
movl 0x24(%rsp), %r9d
leaq 0x8(%rsp), %rdi
callq 0x2058b0
movl %eax, 0x24(%rsp)
movq 0x10(%rsp), %rax
addq (%rsp), %rax
movq %rax, (%rsp)
cmpl $0x0, 0x24(%rsp)
jne 0x2bb783
movq (%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x20(%rsp), %edx
movq (%rax,%rdx,8), %rax
movq 0x40(%rsp), %rdx
movl 0x14(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
addq (%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x20(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2bb7f0
jmp 0x2bb785
cmpq $0x0, 0x18(%rsp)
je 0x2bb7c5
movq 0x38080c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x25a875(%rip), %rsi    # 0x516013
leaq 0x2cdd57(%rip), %rdx    # 0x5894fc
leaq 0x2cdd71(%rip), %rcx    # 0x58951d
leaq 0x2cdc53(%rip), %r8     # 0x589406
movl $0x128, %r9d            # imm = 0x128
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2bb7c7
movq (%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x20(%rsp), %edx
movq (%rax,%rdx,8), %rax
movl 0x24(%rsp), %edx
subl $0x1, %edx
movl %edx, %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x2bb7f2
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2bb6d2
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-copysort.c
// Function: comparesuperbucketsizes
static int comparesuperbucketsizes(const void *a,const void *b,void *data)
{
  const GtBucketspec2 *bucketspec2 = (const GtBucketspec2 *) data;
  GtUword size1 = superbucketsize(bucketspec2, *(const unsigned int *) a);
  GtUword size2 = superbucketsize(bucketspec2, *(const unsigned int *) b);
  if (size1 < size2)
  {
    return -1;
  }
  if (size1 > size2)
  {
    return 1;
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movl (%rax), %esi
callq 0x2bd020
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %esi
callq 0x2bd020
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jae 0x2bbc1d
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x2bbc3a
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jbe 0x2bbc32
movl $0x1, 0x34(%rsp)
jmp 0x2bbc3a
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-copysort.c
// Function: resetsorted
static void resetsorted(GtBucketspec2 *bucketspec2)
{
  unsigned int idx, idx2;

  for (idx = 0; idx<bucketspec2->numofchars; idx++)
  {
    bucketspec2->superbuckettab[idx].sorted = false;
    for (idx2 = 0; idx2<bucketspec2->numofchars; idx2++)
    {
      GtUword startidx = getstartidx(bucketspec2,idx,idx2),
             endidx = getendidx(bucketspec2,idx,idx2);
      bucketspec2->subbuckettab[idx][idx2].sorted =
        (startidx < endidx) ? false : true;
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x2bbd30
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x1c(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x0, 0x1(%rax)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x2bbd1e
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x2bc6a0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
callq 0x2bc5a0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movl $0x1, %eax
xorl %ecx, %ecx
cmpq %rsi, %rdx
cmovbl %ecx, %eax
cmpl $0x0, %eax
setne %cl
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rax
movl 0x1c(%rsp), %edx
movq (%rax,%rdx,8), %rax
movl 0x18(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
andb $0x1, %cl
movb %cl, 0x1(%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2bbc93
jmp 0x2bbd20
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2bbc61
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/sfx-copysort.c
// Function: determinehardwork
static void determinehardwork(GtBucketspec2 *bucketspec2)
{
  unsigned int idx, idxsource, source, second;

  for (idxsource = 0; idxsource<bucketspec2->numofchars; idxsource++)
  {
    source = bucketspec2->order[idxsource];
    for (second = 0; second < bucketspec2->numofchars; second++)
    {
      if (!bucketspec2->subbuckettab[source][second].sorted && source != second)
      {
        bucketspec2->subbuckettab[source][second].hardworktodo = true;
        bucketspec2->subbuckettab[source][second].sorted = true;
      } else
      {
        bucketspec2->subbuckettab[source][second].hardworktodo = false;
      }
    }
    bucketspec2->superbuckettab[source].sorted = true;
    for (idx = 0; idx < bucketspec2->numofchars; idx++)
    {
      bucketspec2->subbuckettab[idx][source].sorted = true;
    }
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x10(%rsp)
movl -0x10(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x2bbe98
movq -0x8(%rsp), %rax
movq 0x20(%rax), %rax
movl -0x10(%rsp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rsp)
movl $0x0, -0x18(%rsp)
movl -0x18(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x2bbe2b
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x18(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
testb $0x1, 0x1(%rax)
jne 0x2bbdfa
movl -0x14(%rsp), %eax
cmpl -0x18(%rsp), %eax
je 0x2bbdfa
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x18(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x1, (%rax)
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x18(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x1, 0x1(%rax)
jmp 0x2bbe19
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movl -0x14(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x18(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
jmp 0x2bbe1b
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0x2bbd7b
movq -0x8(%rsp), %rax
movq 0x38(%rax), %rax
movl -0x14(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x1, 0x1(%rax)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x14(%rcx), %eax
jae 0x2bbe86
movq -0x8(%rsp), %rax
movq 0x40(%rax), %rax
movl -0xc(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movl -0x14(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movb $0x1, 0x1(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x2bbe4b
jmp 0x2bbe88
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x2bbd4d
retq
nopl (%rax)