LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_rank_1
unsigned int gt_popcount_tab_rank_1(GtPopcountTab *popcount_tab,
                                    unsigned int popcount_c,
                                    GtUword i,
                                    unsigned int pos)
{
  GtUword block;
  gt_assert(pos < popcount_tab->blocksize);
  gt_assert(popcount_c <= popcount_tab->blocksize);

  if (popcount_c == 0)
    return 0;
  if (popcount_c < popcount_tab->blocksize)
    gt_assert(i <
              gt_compact_ulong_store_get(popcount_tab->offsets,
                                         (GtUword) popcount_c + 1) -
              gt_compact_ulong_store_get(popcount_tab->offsets,
                                         (GtUword) popcount_c));
  else {
    gt_assert(i == 0);
    return pos+1;
  }
  block =
    gt_compact_ulong_store_get(
                    popcount_tab->blocks,
                    gt_compact_ulong_store_get(popcount_tab->offsets,
                                               (GtUword) popcount_c) + i);
  block >>= popcount_tab->blocksize - pos - 1;
  return gt_popcount_tab_popcount(block);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x28(%rdi), %eax
cmpl %ecx, %eax
jbe 0x164531
cmpl %esi, %eax
jb 0x164536
testl %esi, %esi
je 0x16451a
movl %ecx, %ebx
movq %rdx, %r15
cmpl %esi, %eax
jbe 0x16451e
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %esi, %r12d
leaq 0x1(%r12), %rsi
callq 0xe3c2c
movq %rax, %r13
movq 0x10(%r14), %rdi
movq %r12, %rsi
callq 0xe3c2c
subq %rax, %r13
cmpq %r15, %r13
jbe 0x16453b
movq 0x8(%r14), %r13
movq 0x10(%r14), %rdi
movq %r12, %rsi
callq 0xe3c2c
addq %rax, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0xe3c2c
notl %ebx
addl 0x28(%r14), %ebx
movl %ebx, %ecx
shrq %cl, %rax
movq %rax, %rcx
shrq %rcx
movabsq $0x5555555555555555, %rdx # imm = 0x5555555555555555
andq %rcx, %rdx
subq %rdx, %rax
movabsq $0x3333333333333333, %rcx # imm = 0x3333333333333333
movq %rax, %rdx
andq %rcx, %rdx
shrq $0x2, %rax
andq %rcx, %rax
addq %rdx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
addq %rax, %rcx
movabsq $0xf0f0f0f0f0f0f0f, %rax # imm = 0xF0F0F0F0F0F0F0F
andq %rcx, %rax
movabsq $0x101010101010101, %rbx # imm = 0x101010101010101
imulq %rax, %rbx
shrq $0x38, %rbx
jmp 0x164525
xorl %ebx, %ebx
jmp 0x164525
testq %r15, %r15
jne 0x164540
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4e823
callq 0x4e8ce
callq 0x4e895
callq 0x4e85c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_block_to_str
void gt_popcount_tab_block_to_str(GtPopcountTab *popcount_tab,
                                  GtUword block,
                                  char *buffer)
{
  unsigned int idx;
  buffer[popcount_tab->blocksize] = 0;
  for (idx = 0; idx < popcount_tab->blocksize; ++idx) {
    buffer[idx] =
      ((block >> (GtUword) (popcount_tab->blocksize - idx - 1)) &
       (GtUword) 1) ==
      (GtUword) 1 ?
      '1' : '0';
  }
}

// Assembly:
movl 0x28(%rdi), %eax
movb $0x0, (%rdx,%rax)
movl 0x28(%rdi), %r8d
testl %r8d, %r8d
je 0x164590
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
addl %eax, %r8d
btq %r8, %rsi
setae %r8b
xorb $0x31, %r8b
movb %r8b, (%rdx,%rcx)
incq %rcx
movl 0x28(%rdi), %r8d
decl %eax
cmpq %r8, %rcx
jb 0x16456f
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_get_offset_for_block
GtUword gt_popcount_tab_get_offset_for_block(GtPopcountTab *popcount_tab,
                                                   GtUword block)
{
  gt_assert(popcount_tab != NULL);
  if (popcount_tab->rev_blocks == NULL)
    gt_popcount_tab_init_rev_offset(popcount_tab);
  return gt_compact_ulong_store_get(popcount_tab->rev_blocks, block);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x164660
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
jne 0x16464a
movl 0x28(%r14), %esi
shrl %esi
movq %r14, %rdi
callq 0x1643ab
movq 0x20(%r14), %rdi
movl %eax, %esi
callq 0xe3b18
movq %rax, 0x18(%r14)
cmpq $0x0, 0x20(%r14)
je 0x164647
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xe3c2c
movq %rax, %r13
cmpl 0x28(%r14), %ebp
jae 0x164610
movq 0x10(%r14), %rdi
movl %ebp, %esi
incq %rsi
callq 0xe3c2c
cmpq %rax, %r15
jne 0x164610
incl %ebp
jmp 0x164614
testl %ebp, %ebp
je 0x164627
movq 0x10(%r14), %rdi
movl %ebp, %esi
callq 0xe3c2c
movq %r15, %r12
subq %rax, %r12
jmp 0x164629
xorl %ebp, %ebp
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xe3c78
incq %r15
cmpq 0x20(%r14), %r15
jb 0x1645e4
movq 0x18(%r14), %rdi
jmp 0x16464a
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe3c2c
callq 0x4e907
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_queue_new
GtPriorityQueue *gt_priority_queue_new(GtCompare cmpfun,
                                       GtUword maxnumofelements)
{
  GtPriorityQueue *pq = gt_malloc(sizeof *pq);
  pq->elements = gt_calloc((maxnumofelements + 1), sizeof (*pq->elements));
  pq->minelement = NULL;
  pq->cmpfun = cmpfun;
  pq->capacity = maxnumofelements;
  pq->numofelements = 0;
  return pq;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x229307(%rip), %r15    # 0x38e134
movl $0x28, %edi
movq %r15, %rsi
movl $0x2b, %edx
callq 0x104226
movq %rax, %r12
leaq 0x1(%rbx), %rdi
movl $0x8, %esi
movq %r15, %rdx
movl $0x2c, %ecx
callq 0x10436a
movq %rax, 0x20(%r12)
movq %r14, (%r12)
movq %rbx, 0x8(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_queue_add
void gt_priority_queue_add(GtPriorityQueue *pq, void *value)
{
  gt_assert(pq != NULL && !gt_priority_queue_is_full(pq));
  if (pq->capacity < (GtUword) GT_MINPQSIZE)
  {
    void **ptr;

    /* store elements in reverse order, i.e.\ with the minimum element
       at the last index */
    /* move 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--)
    {
      if (*(ptr-1) == NULL || pq->cmpfun(*(ptr-1),value) < 0)
      {
        *ptr = *(ptr-1);
      } else
      {
        break;
      }
    }
    *ptr = value;
    pq->numofelements++;
  } else
  {
    GtUword idx = ++pq->numofelements;

    while (true)
    {
      const GtUword newidx = GT_HEAP_PARENT(idx);

      if (newidx == 0 || pq->cmpfun(pq->elements[newidx],value) <= 0)
      {
        break;
      }
      gt_assert(idx > 0);
      pq->elements[idx] = pq->elements[newidx];
      idx = newidx;
    }
    gt_assert(idx > 0);
    pq->elements[idx] = value;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x164f8b
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r15
cmpq %rax, %r15
je 0x164f8b
movq %rsi, %r14
cmpq $0xf, %rax
ja 0x164f1c
leaq (,%r15,8), %r12
addq 0x20(%rbx), %r12
testq %r15, %r15
jle 0x164f76
leaq -0x8(%r12), %r13
movq -0x8(%r12), %rdi
testq %rdi, %rdi
je 0x164f0b
movq %r14, %rsi
callq *(%rbx)
testl %eax, %eax
jns 0x164f6c
movq (%r13), %rax
jmp 0x164f0d
xorl %eax, %eax
movq %rax, (%r12)
movq %r13, %r12
cmpq 0x20(%rbx), %r13
ja 0x164eed
jmp 0x164f6f
incq %r15
movq %r15, 0x10(%rbx)
cmpq $0x2, %r15
jae 0x164f2e
movq %r15, %r12
jmp 0x164f5a
movq %r15, %r12
shrq %r12
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq *(%rbx)
testl %eax, %eax
jle 0x164f62
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rcx
movq %rcx, (%rax,%r15,8)
cmpq $0x3, %r15
movq %r12, %r15
ja 0x164f31
movq %r12, %r15
testq %r12, %r12
je 0x164f90
movq 0x20(%rbx), %rax
movq %r14, (%rax,%r15,8)
jmp 0x164f81
movq %r12, %r13
movq 0x10(%rbx), %r15
movq %r13, %r12
movq %r14, (%r12)
incq %r15
movq %r15, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4ea1e
callq 0x4e9e7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_queue_extract_min
void *gt_priority_queue_extract_min(GtPriorityQueue *pq)
{
  gt_assert(pq != NULL && !gt_priority_queue_is_empty(pq));
  if (pq->capacity < (GtUword) GT_MINPQSIZE)
  {
    gt_assert(pq->numofelements > 0);
    pq->minelement = pq->elements[--pq->numofelements];
  } else
  {
    GtUword idx, child;
    void *lastelement;

    pq->minelement = pq->elements[1];
    lastelement = pq->elements[pq->numofelements--];
    for (idx = 1UL; GT_HEAP_LEFT(idx) <= pq->numofelements; idx = child)
    {
      child = GT_HEAP_LEFT(idx);
      gt_assert(child > 0);
      if (child != pq->numofelements &&
          pq->cmpfun(pq->elements[child + 1],pq->elements[child]) < 0)
      {
        child++;
      }
      if (pq->cmpfun(lastelement,pq->elements[child]) > 0)
      {
        pq->elements[idx] = pq->elements[child];
      } else
      {
        break;
      }
    }
    gt_assert(idx > 0);
    pq->elements[idx] = lastelement;
  }
  return pq->minelement;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x16507e
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x16507e
movq 0x20(%rbx), %rcx
cmpq $0xf, 0x8(%rbx)
ja 0x164fd8
leaq -0x1(%rdx), %rax
movq %rax, 0x10(%rbx)
movq -0x8(%rcx,%rdx,8), %rax
movq %rax, 0x18(%rbx)
jmp 0x16506f
movq 0x8(%rcx), %rax
movq %rax, 0x18(%rbx)
leaq -0x1(%rdx), %rax
movq %rax, 0x10(%rbx)
movq (%rcx,%rdx,8), %r14
movl $0x1, %r13d
cmpq $0x3, %rdx
jb 0x165067
movl $0x1, %r15d
movl $0x2, %r12d
testq %r12, %r12
je 0x165079
movq 0x20(%rbx), %rcx
cmpq %rax, %r12
jne 0x165017
movq %rax, %r13
jmp 0x165031
movq (%rcx,%r12,8), %rsi
movq 0x8(%rcx,%r12,8), %rdi
callq *(%rbx)
testl %eax, %eax
jns 0x16502a
orq $0x1, %r12
movq 0x20(%rbx), %rcx
movq %r12, %r13
movq (%rcx,%r13,8), %rsi
movq %r14, %rdi
callq *(%rbx)
testl %eax, %eax
jle 0x165060
movq 0x20(%rbx), %rax
movq (%rax,%r13,8), %rcx
movq %rcx, (%rax,%r15,8)
leaq (,%r13,2), %r12
movq 0x10(%rbx), %rax
movq %r13, %r15
cmpq %rax, %r12
jbe 0x165004
jmp 0x165063
movq %r15, %r13
movq 0x20(%rbx), %rcx
movq %r14, (%rcx,%r13,8)
movq 0x18(%rbx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4ea55
callq 0x4ea8c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_queue_find_min
const void *gt_priority_queue_find_min(const GtPriorityQueue *pq)
{
  gt_assert(pq != NULL && !gt_priority_queue_is_empty(pq));
  return *(pq->elements +
         (pq->capacity < (GtUword) GT_MINPQSIZE ? pq->numofelements-1
                                                      : 1UL));
}

// Assembly:
testq %rdi, %rdi
je 0x1650ab
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1650ab
movq 0x20(%rdi), %rcx
decq %rax
cmpq $0x10, 0x8(%rdi)
movl $0x1, %edx
cmovbq %rax, %rdx
movq (%rcx,%rdx,8), %rax
retq
pushq %rax
callq 0x4eac3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/priority_queue.c
// Function: gt_priority_queue_cmpulong
static int gt_priority_queue_cmpulong(const void *aptr,const void *bptr)
{
  GtUword a, b;

  gt_assert(aptr != NULL && bptr != NULL);
  a = *((const GtUword *) aptr);
  b = *((const GtUword *) bptr);
  return a < b ? -1 : (a > b ? 1 : 0);
}

// Assembly:
testq %rdi, %rdi
je 0x16558e
testq %rsi, %rsi
je 0x16558e
movq (%rdi), %rax
xorl %ecx, %ecx
cmpq (%rsi), %rax
seta %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %ecx, %eax
retq
pushq %rax
callq 0x4ebe0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/ranked_list.c
// Function: gt_ranked_list_new
GtRankedList* gt_ranked_list_new(GtUword maxsize,
                                 GtCompareWithData comparefunction,
                                 GtFree free_func,
                                 void *compareinfo)
{
  GtRankedList *ranked_list;
  gt_assert(maxsize > 0 && comparefunction != NULL);

  ranked_list = gt_malloc(sizeof (*ranked_list));
  ranked_list->currentsize = 0;
  ranked_list->maxsize = maxsize;
  ranked_list->free_func = free_func;
  ranked_list->comparefunction = comparefunction;
  ranked_list->compareinfo = compareinfo;
  /* ranked_list->root = gt_rbtree_new(comparefunction, free_func, NULL); */
  ranked_list->worstelement = NULL;
  ranked_list->list = gt_dlist_new_with_data(comparefunction, compareinfo);
  return ranked_list;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x165602
movq %rsi, %r14
testq %rsi, %rsi
je 0x165602
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r12
leaq 0x228d94(%rip), %rsi    # 0x38e34e
movl $0x38, %edi
movl $0x35, %edx
callq 0x104226
movq %rax, %r13
xorl %eax, %eax
movq %rax, (%r13)
movq %r12, 0x8(%r13)
movq %r15, 0x18(%r13)
movq %r14, 0x10(%r13)
movq %rbx, 0x28(%r13)
movq %rax, 0x20(%r13)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe5b60
movq %rax, 0x30(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4ec19
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/ranked_list.c
// Function: gt_ranked_list_insert
void gt_ranked_list_insert(GtRankedList *ranked_list, void *elem)
{
  /* bool nodecreated = false; */
  if (ranked_list->currentsize < ranked_list->maxsize)
  {
    if (ranked_list->currentsize == 0 ||
        ranked_list->comparefunction(elem,ranked_list->worstelement,
                                     ranked_list->compareinfo) < 0)
    {
      ranked_list->worstelement = elem;
    }
    /* (void) gt_rbtree_search(ranked_list->root, elem, &nodecreated); */
    gt_dlist_add(ranked_list->list, elem);
    /* if (nodecreated)
    { */
    ranked_list->currentsize++;
    /* } */
  } else
  {
/* new element is not as bad as worst element, so insert it and
  and delete the worst element */
    if (ranked_list->comparefunction(ranked_list->worstelement, elem,
                                     ranked_list->compareinfo) <= 0)
    {
      GtDlistelem *oldelem = gt_dlist_first(ranked_list->list);
      if (ranked_list->free_func != NULL)
        ranked_list->free_func(gt_dlistelem_get_data(oldelem));
      gt_dlist_remove(ranked_list->list, oldelem);
      gt_dlist_add(ranked_list->list, elem);
      ranked_list->worstelement =
                       gt_dlistelem_get_data(gt_dlist_first(ranked_list->list));
      /* (void) gt_rbtree_search(ranked_list->root, elem, &nodecreated);
      if (nodecreated)
      {
        if (gt_rbtree_erase(ranked_list->root, ranked_list->worstelement) != 0)
        {
          fprintf(stderr,"%s: deletion failed\n",__func__);
          exit(GT_EXIT_PROGRAMMING_ERROR);
        }
        ranked_list->worstelement = gt_rbtree_minimum_key(ranked_list->root);
      } */
    } else if (ranked_list->free_func != NULL)
    {
      ranked_list->free_func(elem);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpq 0x8(%rdi), %rax
jae 0x16564a
testq %rax, %rax
je 0x165635
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq *0x10(%rbx)
testl %eax, %eax
jns 0x165639
movq %r14, 0x20(%rbx)
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xe5c3d
incq (%rbx)
jmp 0x1656c5
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
movq %r14, %rsi
callq *0x10(%rbx)
testl %eax, %eax
jle 0x165675
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x1656c5
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq 0x30(%rbx), %rdi
callq 0xe5b94
movq %rax, %r15
movq 0x18(%rbx), %r12
testq %r12, %r12
je 0x165698
movq %r15, %rdi
callq 0xe5c10
movq %rax, %rdi
callq *%r12
movq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0xe5d89
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xe5c3d
movq 0x30(%rbx), %rdi
callq 0xe5b94
movq %rax, %rdi
callq 0xe5c10
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/ranked_list.c
// Function: gt_ranked_list_iter_next
void *gt_ranked_list_iter_next(GtRankedListIter *ranked_list_iter)
{
  /* return gt_rbtree_iter_prev(ranked_list_iter); */
  void *data = NULL;
  if (ranked_list_iter->current_elem != NULL) {
    data = gt_dlistelem_get_data(ranked_list_iter->current_elem);
    ranked_list_iter->current_elem =
                          gt_dlistelem_previous(ranked_list_iter->current_elem);
  }
  return data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1657b1
callq 0xe5c10
movq %rax, %r14
movq (%rbx), %rdi
callq 0xe69ae
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x1657b3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/ranked_list.c
// Function: gt_ranked_list_iter_prev
void *gt_ranked_list_iter_prev(GtRankedListIter *ranked_list_iter)
{
 /* return gt_rbtree_iter_next(ranked_list_iter); */
  void *data = NULL;
  if (ranked_list_iter->current_elem != NULL) {
    data =  gt_dlistelem_get_data(ranked_list_iter->current_elem);
    ranked_list_iter->current_elem =
                              gt_dlistelem_next(ranked_list_iter->current_elem);
  }
  return data;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1657e2
callq 0xe5c10
movq %rax, %r14
movq (%rbx), %rdi
callq 0xe5c20
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x1657e4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/ranked_list.c
// Function: gt_ranked_list_delete
void gt_ranked_list_delete(GtRankedList *ranked_list)
{
  if (ranked_list == NULL) return;
  /* gt_rbtree_delete(ranked_list->root); */
  if (ranked_list->free_func != NULL) {
    GtDlistelem *dlistelem;
    for (dlistelem = gt_dlist_first(ranked_list->list); dlistelem != NULL;
         dlistelem = gt_dlistelem_next(dlistelem)) {
      void *data = gt_dlistelem_get_data(dlistelem);
      ranked_list->free_func(data);
    }
  }

  gt_dlist_delete(ranked_list->list);

  gt_free(ranked_list);
}

// Assembly:
testq %rdi, %rdi
je 0x165852
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x16582e
movq 0x30(%rbx), %rdi
callq 0xe5b94
testq %rax, %rax
je 0x16582e
movq %rax, %r14
movq %r14, %rdi
callq 0xe5c10
movq %rax, %rdi
callq *0x18(%rbx)
movq %r14, %rdi
callq 0xe5c20
movq %rax, %r14
testq %rax, %rax
jne 0x165810
movq 0x30(%rbx), %rdi
callq 0xe5e8d
leaq 0x228b10(%rip), %rsi    # 0x38e34e
movq %rbx, %rdi
movl $0xc2, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_new
GtRBTree *gt_rbtree_new(GtCompareWithData cmp, GtRBTreeFreeFunc free,
                        void *info)
{
  GtRBTree *rt = (GtRBTree *) gt_malloc(sizeof *rt);
  gt_assert(cmp);

  rt->root = NULL;
  rt->cmp = cmp;
  rt->free = free;
  rt->info = info;
  rt->size = 0;

  return rt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x22852f(%rip), %rsi    # 0x38e4c0
movl $0x28, %edi
movl $0x7e, %edx
callq 0x104226
testq %r15, %r15
je 0x165fc0
xorl %ecx, %ecx
movq %rcx, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x20(%rax)
movq %rcx, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x4ec89
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_clear
void gt_rbtree_clear(GtRBTree *tree)
{
  GtRBTreeNode *it;
  GtRBTreeNode *save;
  if (tree != NULL) {
    it = tree->root;
    if (it != NULL) {

      /* Rotate away the left links so that we can treat this like the
         destruction of a linked list */
      while (it != NULL) {
        if (it->link[0] == NULL) {
          /* No left links, just kill the node and move on */
          save = it->link[1];
          if (tree->free != NULL)
            tree->free(it->key);
          gt_free(it);
        } else {
          /* Rotate away the left link and check again */
          save = it->link[0];
          it->link[0] = save->link[1];
          save->link[1] = it;
        }
        it = save;
      }
      tree->size = 0;
      tree->root = NULL;
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0x16605a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x16604f
leaq 0x2284be(%rip), %r14    # 0x38e4c0
movq 0x10(%r15), %r12
testq %r12, %r12
je 0x16601b
movq 0x18(%r12), %rax
movq %rax, 0x10(%r15)
movq %r15, 0x18(%r12)
jmp 0x16603e
movq 0x18(%r15), %r12
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x16602e
movq 0x8(%r15), %rdi
callq *%rax
movq %r15, %rdi
movq %r14, %rsi
movl $0xa0, %edx
callq 0x1045eb
movq %r12, %r15
testq %r12, %r12
jne 0x166002
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_find_with_cmp
void *gt_rbtree_find_with_cmp(const GtRBTree *tree, void *key,
                              GtCompareWithData cmpfunc, void *info)
{
  gt_assert(tree);
  gt_assert(cmpfunc);
  gt_assert(key);
  return gt_rbtree_find_with_cmp_g(tree, key, cmpfunc, info);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1660bd
movq %rdx, %r14
testq %rdx, %rdx
je 0x1660c2
movq %rsi, %r15
testq %rsi, %rsi
je 0x1660c7
movq (%rdi), %r13
testq %r13, %r13
je 0x1660a7
movq %rcx, %rbx
xorl %r12d, %r12d
movq 0x8(%r13), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x1660ac
shrl $0x1f, %eax
movq 0x10(%r13,%rax,8), %r13
testq %r13, %r13
jne 0x166087
jmp 0x1660b0
xorl %r12d, %r12d
jmp 0x1660b0
movq 0x8(%r13), %r12
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4ed32
callq 0x4ecf9
callq 0x4ecc0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_insert
void gt_rbtree_insert(GtRBTree *tree, void *key)
{
  GT_UNUSED bool nodecreated;
  gt_assert(tree);
  gt_assert(key);
  gt_rbtree_insert_g(tree, key, &nodecreated, tree->cmp, tree->info);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x166156
testq %rsi, %rsi
je 0x16615b
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %r8
leaq 0x7(%rsp), %rdx
callq 0x166160
popq %rax
retq
callq 0x4ee16
callq 0x4eddd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_insert_with_cmp
void gt_rbtree_insert_with_cmp(GtRBTree *tree, void *key,
                               GtCompareWithData cmpfunc, void *info)
{
  GT_UNUSED bool nodecreated;
  gt_assert(tree);
  gt_assert(key);
  gt_assert(cmpfunc);
  gt_rbtree_insert_g(tree, key, &nodecreated, cmpfunc, info);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1663a7
testq %rsi, %rsi
je 0x1663ac
movq %rcx, %r8
movq %rdx, %rcx
testq %rdx, %rdx
je 0x1663b1
leaq 0x7(%rsp), %rdx
callq 0x166160
popq %rax
retq
callq 0x4eefa
callq 0x4eec1
callq 0x4ee88
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_search
void* gt_rbtree_search(GtRBTree *tree, void *key, bool *nodecreated)
{
  gt_assert(tree);
  gt_assert(key);
  gt_assert(nodecreated);
  gt_rbtree_insert_g(tree, key, nodecreated, tree->cmp, tree->info);
  return key;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1663de
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1663e3
testq %rdx, %rdx
je 0x1663e8
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %r8
movq %rbx, %rsi
callq 0x166160
movq %rbx, %rax
popq %rbx
retq
callq 0x4efa5
callq 0x4ef6c
callq 0x4ef33
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_search_with_cmp
void* gt_rbtree_search_with_cmp(GtRBTree *tree, void *key,
                                GtCompareWithData cmpfunc, void *info,
                                bool *nodecreated)
{
  gt_assert(tree);
  gt_assert(nodecreated);
  gt_assert(cmpfunc);
  gt_assert(key);
  gt_rbtree_insert_g(tree, key, nodecreated, cmpfunc, info);
  return key;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x16641e
testq %r8, %r8
je 0x166423
movq %rcx, %rax
movq %rdx, %rcx
testq %rdx, %rdx
je 0x166428
movq %rsi, %rbx
testq %rsi, %rsi
je 0x16642d
movq %rbx, %rsi
movq %r8, %rdx
movq %rax, %r8
callq 0x166160
movq %rbx, %rax
popq %rbx
retq
callq 0x4f089
callq 0x4f050
callq 0x4f017
callq 0x4efde
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_walk
int gt_rbtree_walk(const GtRBTree *tree, GtRBTreeAction action, void *actinfo)
{
  gt_assert(tree);
  gt_assert(action);
  if (tree->root != NULL) {
    if (gt_rbtree_recurse(tree->root, action, 0, actinfo) != 0) {
      return -1;
    }
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x166739
testq %rsi, %rsi
je 0x16673e
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x166735
movq %rdx, %rcx
xorl %edx, %edx
callq 0x166743
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x166737
xorl %eax, %eax
popq %rcx
retq
callq 0x4f1df
callq 0x4f1a6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_recurse
static int gt_rbtree_recurse(const GtRBTreeNode *root, GtRBTreeAction action,
                             GtUword level, void *actinfo)
{
  if (root->link[0] == NULL && root->link[1] == NULL) {
    if (action(root->key, GT_RBTREE_LEAF, level, actinfo) != 0) {
      return -1;
    }
  } else {
    if (action(root->key, GT_RBTREE_PREORDER, level, actinfo) != 0) {
      return -2;
    }
    if (root->link[0] != NULL) {
      if (gt_rbtree_recurse(root->link[0], action, level + 1, actinfo) != 0) {
        return -3;
      }
    }
    if (action(root->key, GT_RBTREE_POSTORDER, level, actinfo) != 0) {
      return -4;
    }
    if (root->link[1] != NULL) {
      if (gt_rbtree_recurse(root->link[1], action, level + 1, actinfo) != 0) {
        return -5;
      }
    }
    if (action(root->key, GT_RBTREE_ENDORDER, level, actinfo) != 0) {
      return -6;
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
cmpq $0x0, 0x10(%rdi)
jne 0x16676a
cmpq $0x0, 0x18(%r12)
je 0x166810
movq 0x8(%r12), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testl %ecx, %ecx
je 0x166790
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1667b4
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x166743
movl %eax, %ecx
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
testl %ecx, %ecx
jne 0x166784
movq 0x8(%r12), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
testl %ecx, %ecx
jne 0x166784
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x1667f5
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x166743
movl %eax, %ecx
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
testl %ecx, %ecx
jne 0x166784
movq 0x8(%r12), %rdi
movl $0x2, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x166829
movq 0x8(%r12), %rdi
movl $0x3, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x166784
xorl %eax, %eax
jmp 0x166784
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_walk_stop
int gt_rbtree_walk_stop(const GtRBTree *tree, GtRBTreeAction action,
                        void *actinfo)
{
  gt_assert(tree);
  gt_assert(action);
  if (tree->root != NULL) {
    int retcode = gt_rbtree_recursewithstop(tree->root, action, 0, actinfo);
    RBT_CHECK_RETURN_CODE;
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x166868
testq %rsi, %rsi
je 0x16686d
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x166864
movq %rdx, %rcx
xorl %edx, %edx
callq 0x166872
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x166866
xorl %eax, %eax
popq %rcx
retq
callq 0x4f251
callq 0x4f218
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_recursewithstop
static int gt_rbtree_recursewithstop(const GtRBTreeNode *root,
                                     GtRBTreeAction action,
                                     GtUword level, void *actinfo)
{
  int retcode;

  if (root->link[0] == NULL && root->link[1] == NULL) {
    retcode = action(root->key, GT_RBTREE_LEAF, level, actinfo);
    RBT_CHECK_RETURN_CODE;
  } else {
    retcode = action(root->key, GT_RBTREE_PREORDER, level, actinfo);
    RBT_CHECK_RETURN_CODE;
    if (root->link[0] != NULL) {
      retcode = gt_rbtree_recursewithstop(root->link[0], action,
                                      level + 1, actinfo);
      RBT_CHECK_RETURN_CODE;
    }
    retcode = action(root->key, GT_RBTREE_POSTORDER, level, actinfo);
    RBT_CHECK_RETURN_CODE;
    if (root->link[1] != NULL) {
      retcode = gt_rbtree_recursewithstop(root->link[1], action,
                                      level + 1, actinfo);
      RBT_CHECK_RETURN_CODE;
    }
    retcode = action(root->key, GT_RBTREE_ENDORDER, level, actinfo);
    RBT_CHECK_RETURN_CODE;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
cmpq $0x0, 0x10(%rdi)
jne 0x166899
cmpq $0x0, 0x18(%r12)
je 0x166938
movq 0x8(%r12), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x16695b
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1668e3
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x166872
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x16695b
movq 0x8(%r12), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x16695b
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x16692c
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x166872
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x16695b
movq 0x8(%r12), %rdi
movl $0x2, %esi
jmp 0x166942
movq 0x8(%r12), %rdi
movl $0x3, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x16695b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_walk_reverse
int gt_rbtree_walk_reverse(const GtRBTree *tree, GtRBTreeAction action,
                           void *actinfo)
{
  gt_assert(tree);
  gt_assert(action);
  if (tree->root != NULL) {
    if (gt_rbtree_recursereverseorder(tree->root, action, 0, actinfo) != 0) {
      return -1;
    }
  }
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x166993
testq %rsi, %rsi
je 0x166998
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x16698f
movq %rdx, %rcx
xorl %edx, %edx
callq 0x16699d
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x166991
xorl %eax, %eax
popq %rcx
retq
callq 0x4f2c3
callq 0x4f28a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_recursereverseorder
static int gt_rbtree_recursereverseorder(const GtRBTreeNode *root,
                                         GtRBTreeAction action,
                                         GtUword level, void *actinfo)
{
  if (root->link[0] == NULL && root->link[1] == NULL) {
    if (action(root->key, GT_RBTREE_LEAF, level, actinfo) != 0)
    {
      return -1;
    }
  } else {
    if (action(root->key, GT_RBTREE_PREORDER, level, actinfo) != 0) {
      return -2;
    }
    if (root->link[1] != NULL) {
      if (gt_rbtree_recursereverseorder(root->link[1], action, level + 1,
                                        actinfo) != 0) {
        return -3;
      }
    }
    if (action(root->key, GT_RBTREE_POSTORDER, level, actinfo) != 0) {
      return -4;
    }
    if (root->link[0] != NULL) {
      if (gt_rbtree_recursereverseorder(root->link[0], action, level + 1,
                                        actinfo) != 0) {
        return -5;
      }
    }
    if (action (root->key, GT_RBTREE_ENDORDER, level, actinfo) != 0) {
      return -6;
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
cmpq $0x0, 0x10(%rdi)
jne 0x1669c4
cmpq $0x0, 0x18(%r12)
je 0x166a6a
movq 0x8(%r12), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testl %ecx, %ecx
je 0x1669ea
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x166a0e
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x16699d
movl %eax, %ecx
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
testl %ecx, %ecx
jne 0x1669de
movq 0x8(%r12), %rdi
movl $0x1, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xfffffffc, %eax       # imm = 0xFFFFFFFC
testl %ecx, %ecx
jne 0x1669de
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x166a4f
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x16699d
movl %eax, %ecx
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
testl %ecx, %ecx
jne 0x1669de
movq 0x8(%r12), %rdi
movl $0x2, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x166a83
movq 0x8(%r12), %rdi
movl $0x3, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x1669de
xorl %eax, %eax
jmp 0x1669de
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_root_key
void* gt_rbtree_root_key(const GtRBTree *tree)
{
  gt_assert(tree);
  if (tree->size == 0 || tree->root == NULL)
    return NULL;
  else
    return tree->root->key;
}

// Assembly:
testq %rdi, %rdi
je 0x166b00
cmpq $0x0, 0x18(%rdi)
je 0x166afd
movq (%rdi), %rax
testq %rax, %rax
je 0x166afd
movq 0x8(%rax), %rax
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x4f36e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_previous_key
void* gt_rbtree_previous_key(const GtRBTree *tree, void *key,
                             GtCompareWithData cmpfun, void *cmpinfo)
{
  int cmp;
  const GtRBTreeNode *current,
                     *found = NULL;
  gt_assert(tree);
  gt_assert(key);
  gt_assert(cmpfun);
  current = tree->root;

  while (current != NULL) {
    cmp = cmpfun(key, current->key, cmpinfo);
    if (cmp == 0) {
      if (current->link[0] == NULL) {
        if (found == NULL) {
          return NULL;
        }
        return found->key;
      }
      return gt_rbtree_maximum_key_for_node(current->link[0]);
    } else {
      if (cmp < 0) {
        current = current->link[0];
      } else {
        found = current;
        current = current->link[1];
      }
    }
  }
  if (found == NULL) {
    return NULL;
  }
  return found->key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x166b8b
movq %rsi, %r15
testq %rsi, %rsi
je 0x166b90
movq %rdx, %r14
testq %rdx, %rdx
je 0x166b95
movq (%rdi), %r13
testq %r13, %r13
je 0x166b7f
movq %rcx, %rbx
xorl %r12d, %r12d
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x166b5c
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovnsq %r13, %r12
movq 0x10(%r13,%rcx,8), %r13
testq %r13, %r13
jne 0x166b32
jmp 0x166b73
movq 0x10(%r13), %rax
testq %rax, %rax
je 0x166b73
movq %rax, %r12
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x166b65
jmp 0x166b78
testq %r12, %r12
je 0x166b7f
movq 0x8(%r12), %rax
jmp 0x166b81
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4f419
callq 0x4f3e0
callq 0x4f3a7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_previous_equal_key
void* gt_rbtree_previous_equal_key(const GtRBTree *tree, void *key,
                                   GtCompareWithData cmpfun, void *cmpinfo)
{
  int cmp;
  const GtRBTreeNode *current,
                     *found = NULL;
  gt_assert(tree);
  gt_assert(key);
  gt_assert(cmpfun);
  current = tree->root;

  while (current != NULL) {
    cmp = cmpfun(key, current->key, cmpinfo);
    if (cmp == 0) {
      return current->key;
    } else {
      if (cmp < 0) {
        current = current->link[0];
      } else {
        found = current;
        current = current->link[1];
      }
    }
  }
  if (found == NULL) {
    return NULL;
  }
  return found->key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x166c09
movq %rsi, %r15
testq %rsi, %rsi
je 0x166c0e
movq %rdx, %r14
testq %rdx, %rdx
je 0x166c13
movq (%rdi), %r13
testq %r13, %r13
je 0x166bf3
movq %rcx, %rbx
xorl %r12d, %r12d
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x166bf7
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovnsq %r13, %r12
movq 0x10(%r13,%rcx,8), %r13
testq %r13, %r13
jne 0x166bc6
testq %r12, %r12
jne 0x166bfa
xorl %eax, %eax
jmp 0x166bff
movq %r13, %r12
movq 0x8(%r12), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4f4c4
callq 0x4f48b
callq 0x4f452
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_next_key
void* gt_rbtree_next_key(const GtRBTree *tree, void *key,
                         GtCompareWithData cmpfun, void *cmpinfo)
{
  int cmp;
  const GtRBTreeNode *current,
                     *found = NULL;
  gt_assert(tree);
  gt_assert(key);
  gt_assert(cmpfun);
  current = tree->root;

  while (current != NULL) {
    cmp = cmpfun(key, current->key, cmpinfo);
    if (cmp == 0) {
      if (current->link[1] == NULL) {
        if (found == NULL) {
          return NULL;
        }
        return found->key;
      }
      return gt_rbtree_minimum_key_for_node(current->link[1]);
    } else {
      if (cmp < 0) {
        found = current;
        current = current->link[0];
      } else {
        current = current->link[1];
      }
    }
  }
  if (found == NULL) {
    return NULL;
  }
  return found->key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x166c9d
movq %rsi, %r15
testq %rsi, %rsi
je 0x166ca2
movq %rdx, %r14
testq %rdx, %rdx
je 0x166ca7
movq (%rdi), %r13
testq %r13, %r13
je 0x166c91
movq %rcx, %rbx
xorl %r12d, %r12d
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x166c6e
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
testl %eax, %eax
cmovsq %r13, %r12
movq 0x10(%r13,%rcx,8), %r13
testq %r13, %r13
jne 0x166c44
jmp 0x166c85
movq 0x18(%r13), %rax
testq %rax, %rax
je 0x166c85
movq %rax, %r12
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x166c77
jmp 0x166c8a
testq %r12, %r12
je 0x166c91
movq 0x8(%r12), %rax
jmp 0x166c93
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4f56f
callq 0x4f536
callq 0x4f4fd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_iter_new_from_first
GtRBTreeIter* gt_rbtree_iter_new_from_first(const GtRBTree *tree)
{
  GtRBTreeIter *trav = gt_malloc(sizeof (GtRBTreeIter));
  gt_assert(tree);
  (void) start(trav, tree, 0);
  return trav;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x22778b(%rip), %rsi    # 0x38e4c0
movl $0x218, %edi            # imm = 0x218
movl $0x30f, %edx            # imm = 0x30F
callq 0x104226
testq %rbx, %rbx
je 0x166d90
movq %rbx, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x210(%rax)
testq %rcx, %rcx
je 0x166d8e
cmpq $0x0, 0x10(%rcx)
je 0x166d8e
xorl %edx, %edx
movq %rcx, 0x10(%rax,%rdx,8)
incq %rdx
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x10(%rcx)
jne 0x166d6c
movq %rdx, 0x210(%rax)
popq %rbx
retq
callq 0x4f653
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_iter_new_from_last
GtRBTreeIter* gt_rbtree_iter_new_from_last(const GtRBTree *tree)
{
  GtRBTreeIter *trav = gt_malloc(sizeof (GtRBTreeIter));
  gt_assert(tree);
  (void) start(trav, tree, 1);
  return trav;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x227720(%rip), %rsi    # 0x38e4c0
movl $0x218, %edi            # imm = 0x218
movl $0x317, %edx            # imm = 0x317
callq 0x104226
testq %rbx, %rbx
je 0x166dfb
movq %rbx, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x210(%rax)
testq %rcx, %rcx
je 0x166df9
cmpq $0x0, 0x18(%rcx)
je 0x166df9
xorl %edx, %edx
movq %rcx, 0x10(%rax,%rdx,8)
incq %rdx
movq 0x8(%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x18(%rcx)
jne 0x166dd7
movq %rdx, 0x210(%rax)
popq %rbx
retq
callq 0x4f68c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_iter_data
void *gt_rbtree_iter_data (GtRBTreeIter *trav)
{
  GtRBTreeNode *node;
  gt_assert(trav);
  node = trav->it;
  return (node != NULL ? node->key : NULL);
}

// Assembly:
testq %rdi, %rdi
je 0x167006
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x167003
movq 0x8(%rax), %rax
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x4f7a9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: nrbt_walk_tree
static int nrbt_walk_tree(GtRBTree *tree,GtUword expected_count)
{
  GtUword i;
  int error = 0;

  memset(gt_rbtree_ztab, 0, (GT_RBTREE_SIZE * sizeof (*gt_rbtree_ztab)));
  gt_rbtree_max_depth = 0;

  if (gt_rbtree_walk(tree, nrbt_walk_action, NULL) != 0) {
    gt_xfputs("walk failed\n", stdout);
    error = 1;
  }
  for (i = 0; i < expected_count; ++i) {
    if (gt_rbtree_ztab[i] != 1UL) {
      gt_xfputs("Node was not visited.\n", stdout);
      error = 1;
    }
  }
  if (gt_rbtree_max_depth >
      (GtUword) (log ((double) expected_count) * 2.0 +
                       2.0)) {
    printf("Depth too large during tree walk ("GT_WU" vs "GT_WU").\n",
                         gt_rbtree_max_depth,
                         (GtUword) (log ((double) expected_count) * 2.0 +
                         2.0) );
    error = 1;
  }
  return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x356818(%rip), %rdi    # 0x4be818
xorl %ebx, %ebx
movl $0x320, %edx            # imm = 0x320
xorl %esi, %esi
callq 0x173a0
movq $0x0, 0x35680f(%rip) # 0x4be828
leaq 0x9c(%rip), %rsi        # 0x1680bc
movq %r14, %rdi
xorl %edx, %edx
callq 0x16670d
testl %eax, %eax
je 0x168049
movq 0x350ea3(%rip), %rax    # 0x4b8ed8
movq (%rax), %rsi
leaq 0x226b07(%rip), %rdi    # 0x38eb46
callq 0x11f82c
movl $0x1, %ebx
movq 0x3567c8(%rip), %rax    # 0x4be818
xorl %r15d, %r15d
movq 0x350e7e(%rip), %r12    # 0x4b8ed8
leaq 0x226af2(%rip), %r14    # 0x38eb53
cmpq $0x1, (%rax,%r15,8)
je 0x168080
movq (%r12), %rsi
movq %r14, %rdi
callq 0x11f82c
movl $0x1, %ebx
movq 0x356798(%rip), %rax    # 0x4be818
incq %r15
cmpq $0x64, %r15
jne 0x168061
movq 0x356798(%rip), %rsi    # 0x4be828
cmpq $0xc, %rsi
jb 0x1680ae
leaq 0x226acd(%rip), %rdi    # 0x38eb6a
movl $0xb, %edx
xorl %eax, %eax
callq 0x17070
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rbtree.c
// Function: nrbt_walk_action
static int nrbt_walk_action(void* nodekey, const GtRBTreeContext which,
                            const GtUword depth, GT_UNUSED void *actinfo)
{
  GtUword key = *(GtUword *) nodekey;

  if (depth > gt_rbtree_max_depth) {
    gt_rbtree_max_depth = depth;
  }
  if (which == GT_RBTREE_LEAF || which == GT_RBTREE_PREORDER) {
    ++gt_rbtree_ztab[key];
    gt_rbtree_depths[key] = depth;
  } else {
    if (gt_rbtree_depths[key] != depth) {
      gt_xfputs("Depth for one element is not constant during tree walk.\n",
                stdout);
      return -1;
    }
  }
  return 0;
}

// Assembly:
movq (%rdi), %rcx
cmpq %rdx, 0x356762(%rip)    # 0x4be828
jae 0x1680cf
movq %rdx, 0x356759(%rip)    # 0x4be828
cmpl $0x3, %esi
je 0x1680d8
testl %esi, %esi
jne 0x1680f1
movq 0x356739(%rip), %rax    # 0x4be818
incq (%rax,%rcx,8)
movq 0x356736(%rip), %rax    # 0x4be820
movq %rdx, (%rax,%rcx,8)
xorl %eax, %eax
retq
movq 0x356728(%rip), %rsi    # 0x4be820
xorl %eax, %eax
cmpq %rdx, (%rsi,%rcx,8)
je 0x168120
pushq %rax
movq 0x350dd0(%rip), %rax    # 0x4b8ed8
movq (%rax), %rsi
leaq 0x226a88(%rip), %rdi    # 0x38eb9a
callq 0x11f82c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/rcr.c
// Function: gt_rcr_encoder_delete
void gt_rcr_encoder_delete(GtRcrEncoder *rcr_enc)
{
  if (rcr_enc != NULL) {
    gt_huffman_delete(rcr_enc->readlenghts_huff);
    gt_huffman_delete(rcr_enc->qual_mapping_huff);
    gt_huffman_delete(rcr_enc->qual_huff);
    gt_huffman_delete(rcr_enc->cigar_ops_huff);
    gt_huffman_delete(rcr_enc->bases_huff);

    gt_golomb_delete(rcr_enc->readpos_golomb);
    gt_golomb_delete(rcr_enc->varpos_golomb);

    gt_queue_delete(rcr_enc->not_exact_matches);

    bam_destroy1(rcr_enc->sam_align);

    gt_disc_distri_delete(rcr_enc->qual_mapping_distr);
    gt_disc_distri_delete(rcr_enc->readlength_distr);
    gt_disc_distri_delete(rcr_enc->readpos_distr);
    gt_disc_distri_delete(rcr_enc->varpos_distr);
    gt_disc_distri_delete(rcr_enc->qual_distr);

    gt_samfile_iterator_delete(rcr_enc->sam_iter);
    gt_cstr_iterator_delete(rcr_enc->cstr_iterator);
    gt_encdesc_encoder_delete(rcr_enc->encdesc_enc);

    gt_free(rcr_enc->ins_bases);
    gt_free(rcr_enc);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x168e05
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x1543bd
movq 0x70(%rbx), %rdi
callq 0x1543bd
movq 0x68(%rbx), %rdi
callq 0x1543bd
movq 0x78(%rbx), %rdi
callq 0x1543bd
movq 0x80(%rbx), %rdi
callq 0x1543bd
movq 0x50(%rbx), %rdi
callq 0x14c6bb
movq 0x58(%rbx), %rdi
callq 0x14c6bb
movq 0xb0(%rbx), %rdi
callq 0x10dc23
movq 0x90(%rbx), %rax
testq %rax, %rax
je 0x168d88
movq 0x30(%rax), %rdi
callq 0x17fe8
movq 0x90(%rbx), %rdi
callq 0x17fe8
movq 0x40(%rbx), %rdi
callq 0xe5a93
movq 0x20(%rbx), %rdi
callq 0xe5a93
movq 0x28(%rbx), %rdi
callq 0xe5a93
movq 0x30(%rbx), %rdi
callq 0xe5a93
movq 0x38(%rbx), %rdi
callq 0xe5a93
movq 0x88(%rbx), %rdi
callq 0x170a6a
movq 0x18(%rbx), %rdi
callq 0x2fd476
movq 0x48(%rbx), %rdi
callq 0x13cf5a
movq 0xa8(%rbx), %rdi
leaq 0x225ef2(%rip), %r14    # 0x38ecd3
movq %r14, %rsi
movl $0x89a, %edx            # imm = 0x89A
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x89b, %edx            # imm = 0x89B
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq