LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orf_finder_stream.c
// Function: gt_orf_finder_stream_class
const GtNodeStreamClass* gt_orf_finder_stream_class(void)
{
  static const GtNodeStreamClass *gsc;
  gt_class_alloc_lock_enter();
  if (!gsc) {
    gsc = gt_node_stream_class_new(sizeof (GtORFFinderStream),
                                   gt_orf_finder_stream_free,
                                   gt_orf_finder_stream_next);
  }
  gt_class_alloc_lock_leave();
  return gsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x35e64a(%rip)    # 0x4c97f8
jne 0x16b1cf
leaq 0x26(%rip), %rsi        # 0x16b1dd
leaq 0x49(%rip), %rdx        # 0x16b207
movl $0x20, %edi
callq 0x16abb4
movq %rax, 0x35e629(%rip)    # 0x4c97f8
callq 0xe6a19
movq 0x35e61d(%rip), %rax    # 0x4c97f8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orf_finder_stream.c
// Function: gt_orf_finder_stream_next
static int gt_orf_finder_stream_next(GtNodeStream *gs, GtGenomeNode **gn,
                                    GtError *err)
{
  GtORFFinderStream *ls;
  int had_err;

  gt_error_check(err);
  ls = gt_orf_finder_stream_cast(gs);

  had_err = gt_node_stream_next(ls->in_stream, gn, err);
  if (!had_err && *gn) {
    had_err = gt_genome_node_accept(*gn, (GtNodeVisitor*) ls->lv, err);
  }
  if (had_err) {
    gt_genome_node_delete(*gn);
    *gn = NULL;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x16b228
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x16b28a
callq 0x16b1a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16ace8
movl %eax, %ebp
testl %eax, %eax
jne 0x16b26a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x16b268
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x14b992
movl %eax, %ebp
jmp 0x16b26a
xorl %ebp, %ebp
testl %ebp, %ebp
je 0x16b27d
movq (%rbx), %rdi
callq 0x14c43a
movq $0x0, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x4f07e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orf_finder_stream.c
// Function: gt_orf_finder_stream_new
GtNodeStream* gt_orf_finder_stream_new(GtNodeStream *in_stream,
                                       GtRegionMapping *rmap,
                                       GtHashmap *types,
                                       unsigned int min,
                                       unsigned int max,
                                       bool all,
                                       GtError *err)
{
  GtNodeStream *gs;
  GtORFFinderStream *ls;
  gs = gt_node_stream_create(gt_orf_finder_stream_class(), false);
  ls = gt_orf_finder_stream_cast(gs);
  ls->in_stream = gt_node_stream_ref(in_stream);
  ls->lv = (GtORFFinderVisitor*) gt_orf_finder_visitor_new(rmap,types,
                                                           min, max, all, err);
  return gs;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, (%rsp)
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
callq 0x16b1a0
movq %rax, %rdi
xorl %esi, %esi
callq 0x16abec
movq %rax, %rbx
callq 0x16b1a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbp
movq %r15, %rdi
callq 0x16ac58
movq %rax, 0x10(%rbp)
movq %r13, %rdi
movq %r12, %rsi
movl %r14d, %edx
movl (%rsp), %ecx
movl 0x4(%rsp), %r8d
movq 0x40(%rsp), %r9
callq 0x16b8c8
movq %rax, 0x18(%rbp)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orf_finder_visitor.c
// Function: gt_orf_finder_visitor_class
const GtNodeVisitorClass* gt_orf_finder_visitor_class(void)
{
  static const GtNodeVisitorClass *gvc = NULL;
  gt_class_alloc_lock_enter();
  if (!gvc) {
    gvc = gt_node_visitor_class_new(sizeof (GtORFFinderVisitor),
                                    NULL,
                                    NULL,
                                    gt_orf_finder_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return gvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x35e4de(%rip)    # 0x4c9800
jne 0x16b34e
movq $0x0, (%rsp)
leaq 0x29(%rip), %rcx        # 0x16b35c
movl $0x30, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x35e4b2(%rip)    # 0x4c9800
callq 0xe6a19
movq 0x35e4a6(%rip), %rax    # 0x4c9800
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orf_finder_visitor.c
// Function: gt_orf_finder_visitor_new
GtNodeVisitor* gt_orf_finder_visitor_new(GtRegionMapping *rmap,
                                         GtHashmap *types,
                                         unsigned int min,
                                         unsigned int max,
                                         bool all,
                                         GT_UNUSED GtError *err)
{
  GtNodeVisitor *gv;
  GtORFFinderVisitor *lv;
  gv = gt_node_visitor_create(gt_orf_finder_visitor_class());
  lv = gt_orf_finder_visitor_cast(gv);
  gt_assert(lv);
  lv->rmap = rmap;
  lv->types=types;
  lv->min = min;
  lv->max = max;
  lv->all = all;
  return gv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
callq 0x16b314
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r13
callq 0x16b314
movq %rax, %rdi
movq %r13, %rsi
callq 0x16af21
testq %rax, %rax
je 0x16b92a
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movl %r14d, 0x20(%rax)
movl %ebp, 0x24(%rax)
movb %bl, 0x28(%rax)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4f2b6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orf_iterator.c
// Function: gt_orf_iterator_new
GtORFIterator* gt_orf_iterator_new(GtCodonIterator *ci,
                                   GtTranslator *translator)
{
  gt_assert(ci && translator);
  GtORFIterator *orfi = gt_malloc(sizeof (GtORFIterator));
  int i;

  orfi->ci = ci;
  orfi->translator = translator;

  for (i = 0; i < 3; i++) {
    orfi->orf_start[i] = GT_UNDEF_UWORD;
    orfi->found_start[i] = false;
  }
  return orfi;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16bb74
movq %rsi, %rbx
testq %rsi, %rsi
je 0x16bb74
movq %rdi, %r14
leaq 0x22b189(%rip), %rsi    # 0x396cc4
movl $0x30, %edi
movl $0x27, %edx
callq 0x1092b2
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x10(%rax)
movq $-0x1, 0x20(%rax)
movw $0x0, 0x28(%rax)
movb $0x0, 0x2a(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x4f2ef
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orf_iterator.c
// Function: gt_orf_iterator_next
GtORFIteratorStatus gt_orf_iterator_next(
                        GtORFIterator *orfi, GtRange *orf_rng,
                        unsigned int *orf_frame, GtError *err)
{
  gt_assert(orfi);
  unsigned int frame;
  char translated;
  GtTranslatorStatus state;

  while ((state = gt_translator_next(orfi->translator,
                            &translated, &frame, err)) != GT_TRANSLATOR_END) {
    if (state == GT_TRANSLATOR_ERROR)
      return GT_ORF_ITERATOR_ERROR;
    if (translated == GT_START_AMINO && !orfi->found_start[frame]) {
      orfi->orf_start[frame] = gt_codon_iterator_current_position(orfi->ci) - 1;
      orfi->found_start[frame] = true;
    }
    else if ((translated == GT_STOP_AMINO) &&
             (orfi->found_start[frame] == true)) {
      orf_rng->start = orfi->orf_start[frame];
      /* ORF ends before GT_STOP_AMINO */
      orf_rng->end = gt_codon_iterator_current_position(orfi->ci) - 2;
      *orf_frame = frame;
      orfi->found_start[frame] = false;
      return GT_ORF_ITERATOR_OK;
    }
  }
  return GT_ORF_ITERATOR_END;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16bc38
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x3(%rsp), %r13
leaq 0x4(%rsp), %rbp
movq 0x8(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x1247fd
cmpl $-0x3, %eax
ja 0x16bc29
movzbl 0x3(%rsp), %eax
cmpl $0x2a, %eax
je 0x16bbd9
cmpl $0x4d, %eax
jne 0x16bba3
movl 0x4(%rsp), %ecx
cmpb $0x0, 0x28(%r14,%rcx)
je 0x16bbe7
cmpb $0x2a, %al
jne 0x16bba3
movl 0x4(%rsp), %eax
cmpb $0x1, 0x28(%r14,%rax)
jne 0x16bba3
jmp 0x16bc03
movq (%r14), %rdi
callq 0xe6b17
decq %rax
movl 0x4(%rsp), %ecx
movq %rax, 0x10(%r14,%rcx,8)
movb $0x1, 0x28(%r14,%rcx)
jmp 0x16bba3
movq 0x10(%r14,%rax,8), %rax
movq %rax, (%r15)
movq (%r14), %rdi
callq 0xe6b17
addq $-0x2, %rax
movq %rax, 0x8(%r15)
movl 0x4(%rsp), %eax
movl %eax, (%rbx)
movb $0x0, 0x28(%r14,%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4f326
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_delete
void gt_popcount_tab_delete(GtPopcountTab *popcount_tab)
{
  if (popcount_tab != NULL) {
    gt_compact_ulong_store_delete(popcount_tab->blocks);
    gt_compact_ulong_store_delete(popcount_tab->offsets);
    gt_compact_ulong_store_delete(popcount_tab->rev_blocks);
    gt_free(popcount_tab->bit_sizes);
    gt_free(popcount_tab);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x16c103
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xe80b1
movq 0x10(%rbx), %rdi
callq 0xe80b1
movq 0x18(%rbx), %rdi
callq 0xe80b1
movq (%rbx), %rdi
leaq 0x22ad5d(%rip), %r14    # 0x396e3c
movq %r14, %rsi
movl $0x99, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9a, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_get
GtUword gt_popcount_tab_get(GtPopcountTab *popcount_tab,
                                  unsigned int popcount_c,
                                  GtUword i)
{
  gt_assert(popcount_c <= popcount_tab->blocksize);
  if (popcount_c == 0) {
    gt_assert(i == 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 gt_compact_ulong_store_get(
                    popcount_tab->blocks,
                    gt_compact_ulong_store_get(popcount_tab->offsets,
                                               (GtUword) popcount_c) + i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl 0x28(%rdi), %eax
cmpl %esi, %eax
jb 0x16c18e
movq %rdx, %rbx
testl %esi, %esi
je 0x16c14d
movq %rdi, %r14
movl %esi, %r15d
cmpl %esi, %eax
jbe 0x16c160
movq 0x10(%r14), %rdi
leaq 0x1(%r15), %rsi
callq 0xe80ec
movq %rax, %r12
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0xe80ec
subq %rax, %r12
cmpq %rbx, %r12
ja 0x16c165
callq 0x4f589
testq %rbx, %rbx
jne 0x16c193
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
testq %rbx, %rbx
jne 0x16c198
movq 0x8(%r14), %r12
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0xe80ec
addq %rax, %rbx
movq %r12, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe80ec
callq 0x4f5fb
callq 0x4f5c2
callq 0x4f550
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_calculate_size
size_t gt_popcount_tab_calculate_size(unsigned int blocksize)
{
  GtUword num_of_blocks = 1UL << blocksize;
  size_t size = gt_compact_ulong_store_size(num_of_blocks, blocksize);
  size += sizeof (GtPopcountTab);
  size += sizeof (GtUword) * blocksize;
  return size;
}

// Assembly:
pushq %rbx
movl %edi, %ecx
movl %edi, %ebx
movl $0x1, %edi
shlq %cl, %rdi
movl %ecx, %esi
callq 0xe8082
leaq (%rax,%rbx,8), %rax
addq $0x30, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/popcount_tab.c
// Function: gt_popcount_tab_offset_bits
unsigned int gt_popcount_tab_offset_bits(GtPopcountTab *popcount_tab,
                                         unsigned int class)
{
  gt_assert(popcount_tab != NULL);
  gt_assert(class <= popcount_tab->blocksize);
  if (popcount_tab->bit_sizes == NULL) {
    popcount_tab->bit_sizes = gt_calloc((size_t) popcount_tab->blocksize + 1,
                                        sizeof (*(popcount_tab->bit_sizes)));
    gt_popcount_tab_init_bit_sizes(popcount_tab->bit_sizes,
                                   popcount_tab->blocksize);
  }
  return popcount_tab->bit_sizes[class];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16c2b3
movl %esi, %ebx
movq %rdi, %r14
movl 0x28(%rdi), %edi
cmpl %esi, %edi
jb 0x16c2b8
cmpq $0x0, (%r14)
jne 0x16c29c
incq %rdi
leaq 0x22abdc(%rip), %rdx    # 0x396e3c
movl $0x4, %esi
movl $0xf9, %ecx
callq 0x1093ef
movq %rax, %r15
movq %rax, (%r14)
movl 0x28(%r14), %r12d
xorl %ebp, %ebp
movl %ebp, %r13d
movq %r12, %rdi
movq %r13, %rsi
callq 0xe7d9b
movq %rax, %rdi
callq 0x10af48
movl %eax, (%r15,%r13,4)
incl %ebp
cmpl %r12d, %ebp
jbe 0x16c27b
movq (%r14), %rax
movl %ebx, %ecx
movl (%rax,%rcx,4), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4f6df
callq 0x4f6a6
// File: /workspace/github_c_makefile_star2_O1/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 0x16c3b8
cmpl %esi, %eax
jb 0x16c3bd
testl %esi, %esi
je 0x16c3a1
movl %ecx, %ebx
movq %rdx, %r15
cmpl %esi, %eax
jbe 0x16c3a5
movq %rdi, %r14
movq 0x10(%rdi), %rdi
movl %esi, %r12d
leaq 0x1(%r12), %rsi
callq 0xe80ec
movq %rax, %r13
movq 0x10(%r14), %rdi
movq %r12, %rsi
callq 0xe80ec
subq %rax, %r13
cmpq %r15, %r13
jbe 0x16c3c2
movq 0x8(%r14), %r13
movq 0x10(%r14), %rdi
movq %r12, %rsi
callq 0xe80ec
addq %rax, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0xe80ec
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 0x16c3ac
xorl %ebx, %ebx
jmp 0x16c3ac
testq %r15, %r15
jne 0x16c3c7
incl %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4f718
callq 0x4f7c3
callq 0x4f78a
callq 0x4f751
// File: /workspace/github_c_makefile_star2_O1/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 0x16c417
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 0x16c3f6
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16c4dd
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x18(%rdi)
jne 0x16c4c3
movl 0x28(%r14), %esi
shrl %esi
movq %r14, %rdi
callq 0x16c234
movq 0x20(%r14), %rdi
movl %eax, %esi
callq 0xe7fd8
movq %rax, 0x18(%r14)
cmpq $0x0, 0x20(%r14)
je 0x16c4c3
xorl %ebp, %ebp
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0xe80ec
movq %rax, %r13
cmpl 0x28(%r14), %ebp
jae 0x16c496
movq 0x10(%r14), %rdi
movl %ebp, %esi
incq %rsi
callq 0xe80ec
xorl %ecx, %ecx
cmpq %rax, %r15
sete %cl
addl %ecx, %ebp
testl %ebp, %ebp
je 0x16c4ab
movq 0x10(%r14), %rdi
movl %ebp, %esi
callq 0xe80ec
movq %r15, %r12
subq %rax, %r12
movq 0x18(%r14), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xe8138
incq %r15
cmpq 0x20(%r14), %r15
jb 0x16c469
movq 0x18(%r14), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe80ec
callq 0x4f7fc
// File: /workspace/github_c_makefile_star2_O1/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 0x22a7b7(%rip), %r15    # 0x397514
movl $0x28, %edi
movq %r15, %rsi
movl $0x2b, %edx
callq 0x1092b2
movq %rax, %r12
leaq 0x1(%rbx), %rdi
movl $0x8, %esi
movq %r15, %rdx
movl $0x2c, %ecx
callq 0x1093ef
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_O1/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 0x16cea8
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %r15
cmpq %rax, %r15
je 0x16cea8
movq %rsi, %rbx
cmpq $0xf, %rax
ja 0x16ce45
leaq (,%r15,8), %r12
addq 0x20(%r14), %r12
testq %r15, %r15
jle 0x16ce92
movq -0x8(%r12), %rdi
testq %rdi, %rdi
je 0x16ce2c
movq %rbx, %rsi
callq *(%r14)
testl %eax, %eax
jns 0x16ce92
leaq -0x8(%r12), %rax
movq -0x8(%r12), %rcx
movq %rcx, (%r12)
movq %rax, %r12
cmpq 0x20(%r14), %rax
ja 0x16ce18
jmp 0x16ce95
incq %r15
movq %r15, 0x10(%r14)
cmpq $0x2, %r15
jb 0x16ce7d
movq %r15, %r12
shrq %r12
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq *(%r14)
testl %eax, %eax
jle 0x16ce7d
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %rcx
movq %rcx, (%rax,%r15,8)
movb $0x1, %al
movq %r12, %r15
jmp 0x16ce7f
xorl %eax, %eax
testb %al, %al
jne 0x16ce4c
testq %r15, %r15
je 0x16cead
movq 0x20(%r14), %rax
movq %rbx, (%rax,%r15,8)
jmp 0x16ce9c
movq %r12, %rax
movq %rbx, (%rax)
incq 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4f913
callq 0x4f8dc
// File: /workspace/github_c_makefile_star2_O1/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 0x16cf96
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x16cf96
movq 0x20(%rbx), %rdx
cmpq $0xf, 0x8(%rbx)
ja 0x16cef5
leaq -0x1(%rcx), %rax
movq %rax, 0x10(%rbx)
movq -0x8(%rdx,%rcx,8), %rax
movq %rax, 0x18(%rbx)
jmp 0x16cf83
movq 0x8(%rdx), %rax
movq %rax, 0x18(%rbx)
leaq -0x1(%rcx), %rax
movq %rax, 0x10(%rbx)
movq (%rdx,%rcx,8), %r14
movl $0x1, %r13d
cmpq $0x3, %rcx
jb 0x16cf7b
movl $0x1, %r15d
movl $0x2, %r12d
testq %r12, %r12
je 0x16cf91
cmpq %rax, %r12
je 0x16cf42
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rsi
movq 0x8(%rax,%r12,8), %rdi
callq *(%rbx)
testl %eax, %eax
jns 0x16cf42
orq $0x1, %r12
movq %r12, %r13
movq 0x20(%rbx), %rax
movq (%rax,%r12,8), %rsi
movq %r14, %rdi
callq *(%rbx)
testl %eax, %eax
jle 0x16cf78
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 0x16cf21
jmp 0x16cf7b
movq %r15, %r13
movq 0x20(%rbx), %rax
movq %r14, (%rax,%r13,8)
movq 0x18(%rbx), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4f94a
callq 0x4f981
// File: /workspace/github_c_makefile_star2_O1/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 0x16cfc3
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x16cfc3
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 0x4f9b8
// File: /workspace/github_c_makefile_star2_O1/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 0x16d4cf
testq %rsi, %rsi
je 0x16d4cf
movq (%rdi), %rax
xorl %ecx, %ecx
cmpq (%rsi), %rax
seta %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovael %ecx, %eax
retq
pushq %rax
callq 0x4fad5
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x16d546
movq %rsi, %r14
testq %rsi, %rsi
je 0x16d546
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r12
leaq 0x22a230(%rip), %rsi    # 0x39772e
movl $0x38, %edi
movl $0x35, %edx
callq 0x1092b2
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 0xea0c4
movq %rax, 0x30(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4fb0e
// File: /workspace/github_c_makefile_star2_O1/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 0x16d58e
testq %rax, %rax
je 0x16d579
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq *0x10(%rbx)
testl %eax, %eax
jns 0x16d57d
movq %r14, 0x20(%rbx)
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xea1a1
incq (%rbx)
jmp 0x16d609
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
movq %r14, %rsi
callq *0x10(%rbx)
testl %eax, %eax
jle 0x16d5b9
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x16d609
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq 0x30(%rbx), %rdi
callq 0xea0f8
movq %rax, %r15
movq 0x18(%rbx), %r12
testq %r12, %r12
je 0x16d5dc
movq %r15, %rdi
callq 0xea174
movq %rax, %rdi
callq *%r12
movq 0x30(%rbx), %rdi
movq %r15, %rsi
callq 0xea2ed
movq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0xea1a1
movq 0x30(%rbx), %rdi
callq 0xea0f8
movq %rax, %rdi
callq 0xea174
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16d6f5
callq 0xea174
movq %rax, %r14
movq (%rbx), %rdi
callq 0xeaf4f
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x16d6f7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16d726
callq 0xea174
movq %rax, %r14
movq (%rbx), %rdi
callq 0xea184
movq %rax, (%rbx)
movq %r14, %rax
jmp 0x16d728
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16d796
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x16d772
movq 0x30(%rbx), %rdi
callq 0xea0f8
testq %rax, %rax
je 0x16d772
movq %rax, %r14
movq %r14, %rdi
callq 0xea174
movq %rax, %rdi
callq *0x18(%rbx)
movq %r14, %rdi
callq 0xea184
movq %rax, %r14
testq %rax, %rax
jne 0x16d754
movq 0x30(%rbx), %rdi
callq 0xea3f1
leaq 0x229fac(%rip), %rsi    # 0x39772e
movq %rbx, %rdi
movl $0xc2, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2299cb(%rip), %rsi    # 0x3978a0
movl $0x28, %edi
movl $0x7e, %edx
callq 0x1092b2
testq %r15, %r15
je 0x16df04
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 0x4fb7e
// File: /workspace/github_c_makefile_star2_O1/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 0x16df9e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x16df93
leaq 0x22995a(%rip), %r14    # 0x3978a0
movq 0x10(%r15), %r12
testq %r12, %r12
je 0x16df5f
movq 0x18(%r12), %rax
movq %rax, 0x10(%r15)
movq %r15, 0x18(%r12)
jmp 0x16df82
movq 0x18(%r15), %r12
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x16df72
movq 0x8(%r15), %rdi
callq *%rax
movq %r15, %rdi
movq %r14, %rsi
movl $0xa0, %edx
callq 0x109670
movq %r12, %r15
testq %r12, %r12
jne 0x16df46
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_O1/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x16e006
movq %rdx, %r14
testq %rdx, %rdx
je 0x16e00b
movq %rsi, %r15
testq %rsi, %rsi
je 0x16e010
movq %rcx, %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x16dfe9
movq 0x8(%r12), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x16dfe3
movl %eax, %ecx
shrl $0x1f, %ecx
movq 0x10(%r12,%rcx,8), %r12
testl %eax, %eax
jne 0x16dfc2
jmp 0x16dfec
xorl %r12d, %r12d
testq %r12, %r12
je 0x16dff8
movq 0x8(%r12), %rax
jmp 0x16dffa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4fc27
callq 0x4fbee
callq 0x4fbb5
// File: /workspace/github_c_makefile_star2_O1/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 0x16e0a0
testq %rsi, %rsi
je 0x16e0a5
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %r8
leaq 0x7(%rsp), %rdx
callq 0x16e0aa
popq %rax
retq
callq 0x4fd0b
callq 0x4fcd2
// File: /workspace/github_c_makefile_star2_O1/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 0x16e301
testq %rsi, %rsi
je 0x16e306
movq %rcx, %r8
movq %rdx, %rcx
testq %rdx, %rdx
je 0x16e30b
leaq 0x7(%rsp), %rdx
callq 0x16e0aa
popq %rax
retq
callq 0x4fdef
callq 0x4fdb6
callq 0x4fd7d
// File: /workspace/github_c_makefile_star2_O1/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 0x16e338
movq %rsi, %rbx
testq %rsi, %rsi
je 0x16e33d
testq %rdx, %rdx
je 0x16e342
movq 0x8(%rdi), %rcx
movq 0x20(%rdi), %r8
movq %rbx, %rsi
callq 0x16e0aa
movq %rbx, %rax
popq %rbx
retq
callq 0x4fe9a
callq 0x4fe61
callq 0x4fe28
// File: /workspace/github_c_makefile_star2_O1/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 0x16e378
testq %r8, %r8
je 0x16e37d
movq %rcx, %rax
movq %rdx, %rcx
testq %rdx, %rdx
je 0x16e382
movq %rsi, %rbx
testq %rsi, %rsi
je 0x16e387
movq %rbx, %rsi
movq %r8, %rdx
movq %rax, %r8
callq 0x16e0aa
movq %rbx, %rax
popq %rbx
retq
callq 0x4ff7e
callq 0x4ff45
callq 0x4ff0c
callq 0x4fed3
// File: /workspace/github_c_makefile_star2_O1/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 0x16e6bd
testq %rsi, %rsi
je 0x16e6c2
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x16e6b9
movq %rdx, %rcx
xorl %edx, %edx
callq 0x16e6c7
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x16e6bb
xorl %eax, %eax
popq %rcx
retq
callq 0x500d4
callq 0x5009b
// File: /workspace/github_c_makefile_star2_O1/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 0x16e6ee
cmpq $0x0, 0x18(%r12)
je 0x16e794
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 0x16e714
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x16e738
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x16e6c7
movl %eax, %ecx
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
testl %ecx, %ecx
jne 0x16e708
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 0x16e708
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x16e779
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x16e6c7
movl %eax, %ecx
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
testl %ecx, %ecx
jne 0x16e708
movq 0x8(%r12), %rdi
movl $0x2, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x16e7ad
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 0x16e708
xorl %eax, %eax
jmp 0x16e708
// File: /workspace/github_c_makefile_star2_O1/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 0x16e7ec
testq %rsi, %rsi
je 0x16e7f1
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x16e7e8
movq %rdx, %rcx
xorl %edx, %edx
callq 0x16e7f6
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x16e7ea
xorl %eax, %eax
popq %rcx
retq
callq 0x50146
callq 0x5010d
// File: /workspace/github_c_makefile_star2_O1/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 0x16e81d
cmpq $0x0, 0x18(%r12)
je 0x16e8bc
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 0x16e8df
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x16e867
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x16e7f6
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x16e8df
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 0x16e8df
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x16e8b0
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x16e7f6
testl %eax, %eax
sets %cl
cmpl $0x1, %eax
sete %dl
orb %cl, %dl
jne 0x16e8df
movq 0x8(%r12), %rdi
movl $0x2, %esi
jmp 0x16e8c6
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 0x16e8df
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16e917
testq %rsi, %rsi
je 0x16e91c
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x16e913
movq %rdx, %rcx
xorl %edx, %edx
callq 0x16e921
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x16e915
xorl %eax, %eax
popq %rcx
retq
callq 0x501b8
callq 0x5017f
// File: /workspace/github_c_makefile_star2_O1/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 0x16e948
cmpq $0x0, 0x18(%r12)
je 0x16e9ee
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 0x16e96e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x16e992
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x16e921
movl %eax, %ecx
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
testl %ecx, %ecx
jne 0x16e962
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 0x16e962
movq 0x10(%r12), %rdi
testq %rdi, %rdi
je 0x16e9d3
leaq 0x1(%r15), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x16e921
movl %eax, %ecx
movl $0xfffffffb, %eax       # imm = 0xFFFFFFFB
testl %ecx, %ecx
jne 0x16e962
movq 0x8(%r12), %rdi
movl $0x2, %esi
movq %r15, %rdx
movq %r14, %rcx
callq *%rbx
movl %eax, %ecx
movl $0xfffffffa, %eax       # imm = 0xFFFFFFFA
jmp 0x16ea07
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 0x16e962
xorl %eax, %eax
jmp 0x16e962
// File: /workspace/github_c_makefile_star2_O1/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 0x16ea84
cmpq $0x0, 0x18(%rdi)
je 0x16ea81
movq (%rdi), %rax
testq %rax, %rax
je 0x16ea81
movq 0x8(%rax), %rax
retq
xorl %eax, %eax
retq
pushq %rax
callq 0x50263