LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x105525
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r15
cmpq %rax, %r15
je 0x105525
movq %rsi, %rbx
cmpq $0xf, %rax
ja 0x1054d6
movq 0x20(%r14), %rax
leaq (%rax,%r15,8), %r15
cmpq %rax, %r15
jbe 0x1054cd
leaq -0x8(%r15), %r12
movq -0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1054bf
movq %rbx, %rsi
callq *(%r14)
testl %eax, %eax
jns 0x1054cd
movq (%r12), %rax
jmp 0x1054c1
xorl %eax, %eax
movq %rax, (%r15)
movq 0x20(%r14), %rax
movq %r12, %r15
jmp 0x10549d
movq %rbx, (%r15)
incq 0x10(%r14)
jmp 0x105519
incq %r15
movq %r15, 0x10(%r14)
cmpq $0x2, %r15
jb 0x10550c
movq %r15, %r12
shrq %r12
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq *(%r14)
testl %eax, %eax
jle 0x105511
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %rcx
movq %rcx, (%rax,%r15,8)
movq %r12, %r15
jmp 0x1054dd
testq %r15, %r15
je 0x10555b
movq 0x20(%r14), %rax
movq %rbx, (%rax,%r15,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x332a3c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dfadd(%rip), %rsi    # 0x2e5013
leaq 0x229045(%rip), %rdx    # 0x32e582
leaq 0x22906b(%rip), %rcx    # 0x32e5af
leaq 0x228fd9(%rip), %r8     # 0x32e524
pushq $0x42
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x332a06(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dfaa7(%rip), %rsi    # 0x2e5013
leaq 0x20348e(%rip), %rdx    # 0x308a01
leaq 0x229035(%rip), %rcx    # 0x32e5af
leaq 0x228fa3(%rip), %r8     # 0x32e524
pushq $0x67
jmp 0x10554d
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x105673
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x105673
movq 0x20(%rbx), %rdx
cmpq $0xf, 0x8(%rbx)
ja 0x1055c4
leaq -0x1(%rcx), %rax
movq %rax, 0x10(%rbx)
movq -0x8(%rdx,%rcx,8), %rax
movq %rax, 0x18(%rbx)
jmp 0x10563d
movq 0x8(%rdx), %rax
movq %rax, 0x18(%rbx)
leaq -0x1(%rcx), %rax
movq %rax, 0x10(%rbx)
movq (%rdx,%rcx,8), %r14
pushq $0x1
popq %r15
leaq (%r15,%r15), %r12
cmpq %rax, %r12
ja 0x105631
testq %r12, %r12
je 0x105649
movq 0x20(%rbx), %rcx
cmpq %rax, %r12
jne 0x1055f8
movq %rax, %r12
jmp 0x10560f
movq (%rcx,%r12,8), %rsi
movq 0x8(%rcx,%r12,8), %rdi
callq *(%rbx)
testl %eax, %eax
jns 0x10560b
orq $0x1, %r12
movq 0x20(%rbx), %rcx
movq (%rcx,%r12,8), %rsi
movq %r14, %rdi
callq *(%rbx)
movq 0x20(%rbx), %rcx
testl %eax, %eax
jle 0x105635
movq (%rcx,%r12,8), %rax
movq %rax, (%rcx,%r15,8)
movq 0x10(%rbx), %rax
movq %r12, %r15
jmp 0x1055dc
movq 0x20(%rbx), %rcx
movq %r14, (%rcx,%r15,8)
movq 0x18(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x332918(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1df9b9(%rip), %rsi    # 0x2e5013
leaq 0x228fb0(%rip), %rdx    # 0x32e611
leaq 0x228f8b(%rip), %rcx    # 0x32e5f3
leaq 0x228eb5(%rip), %r8     # 0x32e524
pushq $0x7d
jmp 0x10569b
movq 0x3328ee(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1df98f(%rip), %rsi    # 0x2e5013
leaq 0x228f3a(%rip), %rdx    # 0x32e5c5
leaq 0x228f61(%rip), %rcx    # 0x32e5f3
leaq 0x228e8b(%rip), %r8     # 0x32e524
pushq $0x6e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1056cf
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1056cf
movq 0x20(%rdi), %rcx
decq %rax
cmpq $0x10, 0x8(%rdi)
pushq $0x1
popq %rdx
cmovbq %rax, %rdx
movq (%rcx,%rdx,8), %rax
retq
pushq %rax
movq 0x332891(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1df932(%rip), %rsi    # 0x2e5013
leaq 0x228edd(%rip), %rdx    # 0x32e5c5
leaq 0x228f2c(%rip), %rcx    # 0x32e61b
leaq 0x228e2e(%rip), %r8     # 0x32e524
movl $0x93, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x105c35
testq %rsi, %rsi
je 0x105c35
movq (%rdi), %rax
xorl %ecx, %ecx
cmpq (%rsi), %rax
seta %cl
pushq $-0x1
popq %rax
cmovael %ecx, %eax
retq
pushq %rax
movq 0x33232b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1df3cc(%rip), %rsi    # 0x2e5013
leaq 0x228a48(%rip), %rdx    # 0x32e696
leaq 0x228a5e(%rip), %rcx    # 0x32e6b3
leaq 0x2288c8(%rip), %r8     # 0x32e524
movl $0xa6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x105cd9
movq %rsi, %r14
testq %rsi, %rsi
je 0x105cd9
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r12
leaq 0x228aa8(%rip), %rsi    # 0x32e73e
pushq $0x38
popq %rdi
pushq $0x35
popq %rdx
callq 0x93160
movq %rax, %r13
andq $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x28(%rax)
andq $0x0, 0x20(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6e186
movq %rax, 0x30(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x332288(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1df329(%rip), %rsi    # 0x2e5013
leaq 0x228a13(%rip), %rdx    # 0x32e704
leaq 0x228a33(%rip), %rcx    # 0x32e72b
leaq 0x228a3f(%rip), %r8     # 0x32e73e
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x105d52
testq %rax, %rax
je 0x105d3d
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq *0x10(%rbx)
testl %eax, %eax
jns 0x105d41
movq %r14, 0x20(%rbx)
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x6e34e
incq (%rbx)
jmp 0x105dcd
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
movq %r14, %rsi
callq *0x10(%rbx)
testl %eax, %eax
jle 0x105d7d
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x105dcd
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq 0x30(%rbx), %rdi
callq 0x6e1b4
movq %rax, %r15
movq 0x18(%rbx), %r12
testq %r12, %r12
je 0x105da0
movq %r15, %rdi
callq 0x6e2bb
movq %rax, %rdi
callq *%r12
movq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0x6e631
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x6e34e
movq 0x30(%rbx), %rdi
callq 0x6e1b4
movq %rax, %rdi
callq 0x6e2bb
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x105eb1
callq 0x6e2bb
movq %rax, %r14
movq (%rbx), %rdi
callq 0x6f232
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x105eb3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x105ee2
callq 0x6e2bb
movq %rax, %r14
movq (%rbx), %rdi
callq 0x6e2fe
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x105ee4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x105f4c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x105f28
movq 0x30(%rbx), %rdi
callq 0x6e1b4
movq %rax, %r14
testq %rax, %rax
je 0x105f28
movq %r14, %rdi
callq 0x6e2bb
movq %rax, %rdi
callq *0x18(%rbx)
movq %r14, %rdi
callq 0x6e2fe
jmp 0x105f08
movq 0x30(%rbx), %rdi
callq 0x6e7d8
leaq 0x228806(%rip), %rsi    # 0x32e73e
movq %rbx, %rdi
movl $0xc2, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x228317(%rip), %rsi    # 0x32e8c0
pushq $0x28
popq %rdi
pushq $0x7e
popq %rdx
callq 0x93160
testq %r15, %r15
je 0x1065d4
andq $0x0, (%rax)
movq %r15, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rbx, 0x20(%rax)
andq $0x0, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0x33198d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dea2e(%rip), %rsi    # 0x2e5013
leaq 0x2047d3(%rip), %rdx    # 0x30adbf
leaq 0x2282e3(%rip), %rcx    # 0x32e8d6
leaq 0x2282c6(%rip), %r8     # 0x32e8c0
pushq $0x7f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1066a2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x106697
leaq 0x228279(%rip), %r14    # 0x32e8c0
testq %r15, %r15
je 0x10668e
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x106666
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%r15)
movq %r15, 0x18(%rax)
movq %rax, %r15
jmp 0x106647
movq 0x18(%r15), %r12
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x106679
movq 0x8(%r15), %rdi
callq *%rax
movq %r15, %rdi
movq %r14, %rsi
movl $0xa0, %edx
callq 0x936f9
movq %r12, %r15
jmp 0x106647
andq $0x0, 0x18(%rbx)
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rdi, %rdi
je 0x1066b9
testq %rdx, %rdx
je 0x1066e7
testq %rsi, %rsi
je 0x106715
popq %rax
jmp 0x10674d
movq 0x3318a8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de949(%rip), %rsi    # 0x2e5013
leaq 0x27f597(%rip), %rdx    # 0x385c68
leaq 0x22820c(%rip), %rcx    # 0x32e8e4
leaq 0x2281e1(%rip), %r8     # 0x32e8c0
movl $0xc4, %r9d
jmp 0x106741
movq 0x33187a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de91b(%rip), %rsi    # 0x2e5013
leaq 0x2281fd(%rip), %rdx    # 0x32e8fc
leaq 0x2281de(%rip), %rcx    # 0x32e8e4
leaq 0x2281b3(%rip), %r8     # 0x32e8c0
movl $0xc5, %r9d
jmp 0x106741
movq 0x33184c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de8ed(%rip), %rsi    # 0x2e5013
leaq 0x20bb27(%rip), %rdx    # 0x312254
leaq 0x2281b0(%rip), %rcx    # 0x32e8e4
leaq 0x228185(%rip), %r8     # 0x32e8c0
movl $0xc6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rbtree.c
// Function: gt_rbtree_find_with_cmp_g
static inline void *gt_rbtree_find_with_cmp_g(const GtRBTree *tree, void *key,
                                              GtCompareWithData cmpfunc,
                                              void *info)
{
  GtRBTreeNode *it = tree->root;

  while (it != NULL) {
    int cmp = cmpfunc(it->key, key, info);

    if (cmp == 0)
      break;

    it = it->link[(int) (cmp < 0)];
  }

  return it == NULL ? NULL : it->key;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
xorl %ebx, %ebx
movq (%rdi), %r13
testq %r13, %r13
je 0x10678e
movq 0x8(%r13), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq *%r15
testl %eax, %eax
je 0x10678a
shrl $0x1f, %eax
leaq 0x10(,%rax,8), %rdi
addq %r13, %rdi
jmp 0x106761
movq 0x8(%r13), %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x106836
testq %rsi, %rsi
je 0x106864
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %r8
leaq 0x7(%rsp), %rdx
callq 0x10689c
popq %rax
retq
movq 0x33172b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de7cc(%rip), %rsi    # 0x2e5013
leaq 0x27f41a(%rip), %rdx    # 0x385c68
leaq 0x2280be(%rip), %rcx    # 0x32e913
leaq 0x228064(%rip), %r8     # 0x32e8c0
movl $0x122, %r9d            # imm = 0x122
jmp 0x106890
movq 0x3316fd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de79e(%rip), %rsi    # 0x2e5013
leaq 0x20b9d8(%rip), %rdx    # 0x312254
leaq 0x228090(%rip), %rcx    # 0x32e913
leaq 0x228036(%rip), %r8     # 0x32e8c0
movl $0x123, %r9d            # imm = 0x123
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x106a9b
testq %rsi, %rsi
je 0x106ac9
movq %rcx, %r8
movq %rdx, %rcx
testq %rdx, %rdx
je 0x106af7
leaq 0x7(%rsp), %rdx
callq 0x10689c
popq %rax
retq
movq 0x3314c6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de567(%rip), %rsi    # 0x2e5013
leaq 0x27f1b5(%rip), %rdx    # 0x385c68
leaq 0x227e6a(%rip), %rcx    # 0x32e924
leaq 0x227dff(%rip), %r8     # 0x32e8c0
movl $0x12b, %r9d            # imm = 0x12B
jmp 0x106b23
movq 0x331498(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de539(%rip), %rsi    # 0x2e5013
leaq 0x20b773(%rip), %rdx    # 0x312254
leaq 0x227e3c(%rip), %rcx    # 0x32e924
leaq 0x227dd1(%rip), %r8     # 0x32e8c0
movl $0x12c, %r9d            # imm = 0x12C
jmp 0x106b23
movq 0x33146a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de50b(%rip), %rsi    # 0x2e5013
leaq 0x227ded(%rip), %rdx    # 0x32e8fc
leaq 0x227e0e(%rip), %rcx    # 0x32e924
leaq 0x227da3(%rip), %r8     # 0x32e8c0
movl $0x12d, %r9d            # imm = 0x12D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x106b57
movq %rsi, %rbx
testq %rsi, %rsi
je 0x106b85
testq %rdx, %rdx
je 0x106bb3
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %r8
movq %rbx, %rsi
callq 0x10689c
movq %rbx, %rax
popq %rbx
retq
movq 0x33140a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de4ab(%rip), %rsi    # 0x2e5013
leaq 0x27f0f9(%rip), %rdx    # 0x385c68
leaq 0x227dc8(%rip), %rcx    # 0x32e93e
leaq 0x227d43(%rip), %r8     # 0x32e8c0
movl $0x133, %r9d            # imm = 0x133
jmp 0x106bdf
movq 0x3313dc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de47d(%rip), %rsi    # 0x2e5013
leaq 0x20b6b7(%rip), %rdx    # 0x312254
leaq 0x227d9a(%rip), %rcx    # 0x32e93e
leaq 0x227d15(%rip), %r8     # 0x32e8c0
movl $0x134, %r9d            # imm = 0x134
jmp 0x106bdf
movq 0x3313ae(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de44f(%rip), %rsi    # 0x2e5013
leaq 0x213570(%rip), %rdx    # 0x31a13b
leaq 0x227d6c(%rip), %rcx    # 0x32e93e
leaq 0x227ce7(%rip), %r8     # 0x32e8c0
movl $0x135, %r9d            # imm = 0x135
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x106c20
testq %r8, %r8
je 0x106c51
movq %rcx, %rax
movq %rdx, %rcx
testq %rdx, %rdx
je 0x106c7f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x106cad
movq %rbx, %rsi
movq %r8, %rdx
movq %rax, %r8
callq 0x10689c
movq %rbx, %rax
popq %rbx
retq
movq 0x331341(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de3e2(%rip), %rsi    # 0x2e5013
leaq 0x27f030(%rip), %rdx    # 0x385c68
leaq 0x227d10(%rip), %rcx    # 0x32e94f
leaq 0x227c7a(%rip), %r8     # 0x32e8c0
movl $0x13e, %r9d            # imm = 0x13E
jmp 0x106cd9
movq 0x331310(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de3b1(%rip), %rsi    # 0x2e5013
leaq 0x2134d2(%rip), %rdx    # 0x31a13b
leaq 0x227cdf(%rip), %rcx    # 0x32e94f
leaq 0x227c49(%rip), %r8     # 0x32e8c0
movl $0x13f, %r9d            # imm = 0x13F
jmp 0x106cd9
movq 0x3312e2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de383(%rip), %rsi    # 0x2e5013
leaq 0x227c65(%rip), %rdx    # 0x32e8fc
leaq 0x227cb1(%rip), %rcx    # 0x32e94f
leaq 0x227c1b(%rip), %r8     # 0x32e8c0
movl $0x140, %r9d            # imm = 0x140
jmp 0x106cd9
movq 0x3312b4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1de355(%rip), %rsi    # 0x2e5013
leaq 0x20b58f(%rip), %rdx    # 0x312254
leaq 0x227c83(%rip), %rcx    # 0x32e94f
leaq 0x227bed(%rip), %r8     # 0x32e8c0
movl $0x141, %r9d            # imm = 0x141
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1070ef
testq %rsi, %rsi
je 0x10711d
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1070eb
movq %rdx, %rcx
xorl %edx, %edx
callq 0x107155
testl %eax, %eax
je 0x1070eb
pushq $-0x1
popq %rax
jmp 0x1070ed
xorl %eax, %eax
popq %rcx
retq
movq 0x330e72(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ddf13(%rip), %rsi    # 0x2e5013
leaq 0x27eb61(%rip), %rdx    # 0x385c68
leaq 0x22787a(%rip), %rcx    # 0x32e988
leaq 0x2277ab(%rip), %r8     # 0x32e8c0
movl $0x20b, %r9d            # imm = 0x20B
jmp 0x107149
movq 0x330e44(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ddee5(%rip), %rsi    # 0x2e5013
leaq 0x212acd(%rip), %rdx    # 0x319c02
leaq 0x22784c(%rip), %rcx    # 0x32e988
leaq 0x22777d(%rip), %r8     # 0x32e8c0
movl $0x20c, %r9d            # imm = 0x20C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x107178
cmpq $0x0, 0x18(%r12)
je 0x1071d3
movq 0x8(%r12), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
je 0x10719a
pushq $-0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1071bb
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x107155
testl %eax, %eax
je 0x1071bb
pushq $-0x3
jmp 0x10718d
movq 0x8(%r12), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
je 0x1071eb
pushq $-0x4
jmp 0x10718d
movq 0x8(%r12), %rdi
pushq $0x3
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
je 0x107227
pushq $-0x1
jmp 0x10718d
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x10720c
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x107155
testl %eax, %eax
je 0x10720c
pushq $-0x5
jmp 0x10718d
movq 0x8(%r12), %rdi
pushq $0x2
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
je 0x107227
pushq $-0x6
jmp 0x10718d
xorl %eax, %eax
jmp 0x10718e
// File: /workspace/github_c_makefile_star2_O2/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 0x10725e
testq %rsi, %rsi
je 0x10728c
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x10725a
movq %rdx, %rcx
xorl %edx, %edx
callq 0x1072c4
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x10725c
xorl %eax, %eax
popq %rcx
retq
movq 0x330d03(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ddda4(%rip), %rsi    # 0x2e5013
leaq 0x27e9f2(%rip), %rdx    # 0x385c68
leaq 0x22771a(%rip), %rcx    # 0x32e997
leaq 0x22763c(%rip), %r8     # 0x32e8c0
movl $0x218, %r9d            # imm = 0x218
jmp 0x1072b8
movq 0x330cd5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ddd76(%rip), %rsi    # 0x2e5013
leaq 0x21295e(%rip), %rdx    # 0x319c02
leaq 0x2276ec(%rip), %rcx    # 0x32e997
leaq 0x22760e(%rip), %r8     # 0x32e8c0
movl $0x219, %r9d            # imm = 0x219
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1072eb
cmpq $0x0, 0x18(%r12)
je 0x107385
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 0x1073a6
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x107335
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x1072c4
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x1073a6
movq 0x8(%r12), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x1073a6
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x10737c
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x1072c4
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x1073a6
movq 0x8(%r12), %rdi
pushq $0x2
jmp 0x10738c
movq 0x8(%r12), %rdi
pushq $0x3
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x1073a6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1073dc
testq %rsi, %rsi
je 0x10740a
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1073d8
movq %rdx, %rcx
xorl %edx, %edx
callq 0x107442
testl %eax, %eax
je 0x1073d8
pushq $-0x1
popq %rax
jmp 0x1073da
xorl %eax, %eax
popq %rcx
retq
movq 0x330b85(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ddc26(%rip), %rsi    # 0x2e5013
leaq 0x27e874(%rip), %rdx    # 0x385c68
leaq 0x2275b0(%rip), %rcx    # 0x32e9ab
leaq 0x2274be(%rip), %r8     # 0x32e8c0
movl $0x224, %r9d            # imm = 0x224
jmp 0x107436
movq 0x330b57(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ddbf8(%rip), %rsi    # 0x2e5013
leaq 0x2127e0(%rip), %rdx    # 0x319c02
leaq 0x227582(%rip), %rcx    # 0x32e9ab
leaq 0x227490(%rip), %r8     # 0x32e8c0
movl $0x225, %r9d            # imm = 0x225
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x107465
cmpq $0x0, 0x18(%r12)
je 0x1074c0
movq 0x8(%r12), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
je 0x107487
pushq $-0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x1074a8
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x107442
testl %eax, %eax
je 0x1074a8
pushq $-0x3
jmp 0x10747a
movq 0x8(%r12), %rdi
pushq $0x1
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
je 0x1074d8
pushq $-0x4
jmp 0x10747a
movq 0x8(%r12), %rdi
pushq $0x3
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
je 0x107514
pushq $-0x1
jmp 0x10747a
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x1074f9
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x107442
testl %eax, %eax
je 0x1074f9
pushq $-0x5
jmp 0x10747a
movq 0x8(%r12), %rdi
pushq $0x2
popq %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
testl %eax, %eax
je 0x107514
pushq $-0x6
jmp 0x10747a
xorl %eax, %eax
jmp 0x10747b
// File: /workspace/github_c_makefile_star2_O2/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 0x1075ef
cmpq $0x0, 0x18(%rdi)
je 0x1075ec
movq (%rdi), %rax
testq %rax, %rax
je 0x1075ec
movq 0x8(%rax), %rax
retq
xorl %eax, %eax
retq
pushq %rax
movq 0x330971(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dda12(%rip), %rsi    # 0x2e5013
leaq 0x27e660(%rip), %rdx    # 0x385c68
leaq 0x2273df(%rip), %rcx    # 0x32e9ee
leaq 0x2272aa(%rip), %r8     # 0x32e8c0
movl $0x252, %r9d            # imm = 0x252
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1076b0
movq %rsi, %r15
testq %rsi, %rsi
je 0x1076de
movq %rdx, %r14
testq %rdx, %rdx
je 0x10770c
movq %rcx, %rbx
xorl %r12d, %r12d
movq (%rdi), %r13
testq %r13, %r13
je 0x107698
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x107681
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
testl %eax, %eax
leaq 0x10(%r13,%rcx,8), %rdi
cmovnsq %r13, %r12
jmp 0x107654
movq 0x10(%r13), %rdi
testq %rdi, %rdi
je 0x107698
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1075ba
testq %r12, %r12
je 0x1076a4
movq 0x8(%r12), %rax
jmp 0x1076a6
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x3308b1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd952(%rip), %rsi    # 0x2e5013
leaq 0x27e5a0(%rip), %rdx    # 0x385c68
leaq 0x227332(%rip), %rcx    # 0x32ea01
leaq 0x2271ea(%rip), %r8     # 0x32e8c0
movl $0x25f, %r9d            # imm = 0x25F
jmp 0x107738
movq 0x330883(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd924(%rip), %rsi    # 0x2e5013
leaq 0x20ab5e(%rip), %rdx    # 0x312254
leaq 0x227304(%rip), %rcx    # 0x32ea01
leaq 0x2271bc(%rip), %r8     # 0x32e8c0
movl $0x260, %r9d            # imm = 0x260
jmp 0x107738
movq 0x330855(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd8f6(%rip), %rsi    # 0x2e5013
leaq 0x2272f4(%rip), %rdx    # 0x32ea18
leaq 0x2272d6(%rip), %rcx    # 0x32ea01
leaq 0x22718e(%rip), %r8     # 0x32e8c0
movl $0x261, %r9d            # imm = 0x261
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1077b8
movq %rsi, %r15
testq %rsi, %rsi
je 0x1077e6
movq %rdx, %r14
testq %rdx, %rdx
je 0x107814
movq %rcx, %rbx
xorl %r12d, %r12d
movq (%rdi), %r13
testq %r13, %r13
je 0x10779d
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x1077a6
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
testl %eax, %eax
leaq 0x10(%r13,%rcx,8), %rdi
cmovnsq %r13, %r12
jmp 0x107770
testq %r12, %r12
jne 0x1077a9
xorl %eax, %eax
jmp 0x1077ae
movq %r13, %r12
movq 0x8(%r12), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x3307a9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd84a(%rip), %rsi    # 0x2e5013
leaq 0x27e498(%rip), %rdx    # 0x385c68
leaq 0x227248(%rip), %rcx    # 0x32ea1f
leaq 0x2270e2(%rip), %r8     # 0x32e8c0
movl $0x283, %r9d            # imm = 0x283
jmp 0x107840
movq 0x33077b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd81c(%rip), %rsi    # 0x2e5013
leaq 0x20aa56(%rip), %rdx    # 0x312254
leaq 0x22721a(%rip), %rcx    # 0x32ea1f
leaq 0x2270b4(%rip), %r8     # 0x32e8c0
movl $0x284, %r9d            # imm = 0x284
jmp 0x107840
movq 0x33074d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd7ee(%rip), %rsi    # 0x2e5013
leaq 0x2271ec(%rip), %rdx    # 0x32ea18
leaq 0x2271ec(%rip), %rcx    # 0x32ea1f
leaq 0x227086(%rip), %r8     # 0x32e8c0
movl $0x285, %r9d            # imm = 0x285
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1078d4
movq %rsi, %r15
testq %rsi, %rsi
je 0x107902
movq %rdx, %r14
testq %rdx, %rdx
je 0x107930
movq %rcx, %rbx
xorl %r12d, %r12d
movq (%rdi), %r13
testq %r13, %r13
je 0x1078bc
movq 0x8(%r13), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x1078a5
movl %eax, %ecx
notl %ecx
shrl $0x1f, %ecx
testl %eax, %eax
leaq 0x10(%r13,%rcx,8), %rdi
cmovsq %r13, %r12
jmp 0x107878
movq 0x18(%r13), %rdi
testq %rdi, %rdi
je 0x1078bc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10755e
testq %r12, %r12
je 0x1078c8
movq 0x8(%r12), %rax
jmp 0x1078ca
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x33068d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd72e(%rip), %rsi    # 0x2e5013
leaq 0x27e37c(%rip), %rdx    # 0x385c68
leaq 0x227149(%rip), %rcx    # 0x32ea3c
leaq 0x226fc6(%rip), %r8     # 0x32e8c0
movl $0x2a1, %r9d            # imm = 0x2A1
jmp 0x10795c
movq 0x33065f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd700(%rip), %rsi    # 0x2e5013
leaq 0x20a93a(%rip), %rdx    # 0x312254
leaq 0x22711b(%rip), %rcx    # 0x32ea3c
leaq 0x226f98(%rip), %r8     # 0x32e8c0
movl $0x2a2, %r9d            # imm = 0x2A2
jmp 0x10795c
movq 0x330631(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd6d2(%rip), %rsi    # 0x2e5013
leaq 0x2270d0(%rip), %rdx    # 0x32ea18
leaq 0x2270ed(%rip), %rcx    # 0x32ea3c
leaq 0x226f6a(%rip), %r8     # 0x32e8c0
movl $0x2a3, %r9d            # imm = 0x2A3
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x226e42(%rip), %rsi    # 0x32e8c0
movl $0x218, %edi            # imm = 0x218
movl $0x30f, %edx            # imm = 0x30F
callq 0x93160
testq %rbx, %rbx
je 0x107aad
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x107ae5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3304b4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd555(%rip), %rsi    # 0x2e5013
leaq 0x27e1a3(%rip), %rdx    # 0x385c68
leaq 0x226f9c(%rip), %rcx    # 0x32ea68
leaq 0x226ded(%rip), %r8     # 0x32e8c0
movl $0x310, %r9d            # imm = 0x310
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rbtree.c
// Function: start
static inline void *start(GtRBTreeIter *trav, const GtRBTree *tree, int dir)
{
  trav->tree = tree;
  trav->it = tree->root;
  trav->top = 0;

  /* Save the path for later traversal */
  if (trav->it != NULL)
    {
      while (trav->it->link[dir] != NULL)
        {
          trav->path[trav->top++] = trav->it;
          trav->it = trav->it->link[dir];
        }
    }

  return trav->it == NULL ? NULL : trav->it->key;
}

// Assembly:
movq %rsi, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x210(%rdi)
testq %rax, %rax
je 0x107b27
movl %edx, %ecx
pushq $0x1
popq %rdx
cmpq $0x0, 0x10(%rax,%rcx,8)
je 0x107b27
movq %rdx, 0x210(%rdi)
movq %rax, 0x8(%rdi,%rdx,8)
movq 0x8(%rdi), %rax
movq 0x10(%rax,%rcx,8), %rax
movq %rax, 0x8(%rdi)
incq %rdx
jmp 0x107b01
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x226d8a(%rip), %rsi    # 0x32e8c0
movl $0x218, %edi            # imm = 0x218
movl $0x317, %edx            # imm = 0x317
callq 0x93160
testq %rbx, %rbx
je 0x107b66
movq %rax, %r14
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x107ae5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3303fb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1dd49c(%rip), %rsi    # 0x2e5013
leaq 0x27e0ea(%rip), %rdx    # 0x385c68
leaq 0x226f01(%rip), %rcx    # 0x32ea86
leaq 0x226d34(%rip), %r8     # 0x32e8c0
movl $0x318, %r9d            # imm = 0x318
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/rbtree.c
// Function: move
static inline void *move(GtRBTreeIter *trav, int dir, GT_UNUSED bool strict)
{
  if (trav->it->link[dir] != NULL) {
    /* Continue down this branch */
    trav->path[trav->top++] = trav->it;
    trav->it = trav->it->link[dir];

    while (trav->it->link[(int) !dir] != NULL) {
      trav->path[trav->top++] = trav->it;
      trav->it = trav->it->link[(int) !dir];
    }
  } else {
    /* Move to the next branch */
    GtRBTreeNode *last;

    do {
      if (trav->top == 0) {
        trav->it = NULL;
        break;
      }

      last = trav->it;
      trav->it = trav->path[--trav->top];
    } while (last == trav->it->link[dir]);
  }

  return trav->it == NULL ? NULL : trav->it->key;
}

// Assembly:
movq 0x8(%rdi), %rcx
movl %esi, %eax
cmpq $0x0, 0x10(%rcx,%rax,8)
je 0x107cda
movq 0x210(%rdi), %rdx
leaq 0x1(%rdx), %r8
movq %r8, 0x210(%rdi)
movq %rcx, 0x10(%rdi,%rdx,8)
movq 0x8(%rdi), %rcx
leaq (%rcx,%rax,8), %rcx
addq $0x10, %rcx
xorl %eax, %eax
testl %esi, %esi
sete %al
addq $0x2, %rdx
movq (%rcx), %rsi
movq %rsi, 0x8(%rdi)
cmpq $0x0, 0x10(%rsi,%rax,8)
je 0x107d07
movq %rdx, 0x210(%rdi)
movq %rsi, 0x8(%rdi,%rdx,8)
movq 0x8(%rdi), %rcx
leaq (%rcx,%rax,8), %rcx
addq $0x10, %rcx
incq %rdx
jmp 0x107cae
movq 0x210(%rdi), %rdx
decq %rdx
cmpq $-0x1, %rdx
je 0x107d0c
movq %rdx, 0x210(%rdi)
movq 0x10(%rdi,%rdx,8), %rsi
movq %rsi, 0x8(%rdi)
decq %rdx
cmpq 0x10(%rsi,%rax,8), %rcx
movq %rsi, %rcx
je 0x107ce4
movq 0x8(%rsi), %rax
retq
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
retq