LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_find_all_overlapping
void gt_interval_tree_find_all_overlapping(GtIntervalTree *it,
                                           GtUword start,
                                           GtUword end, GtArray* a)
{
  gt_assert(it && a && start <= end);
  if (it->root == it->nil) return;
  interval_tree_find_all_internal(it, it->root, store_interval_node_in_array,
                                  start, end, a);
}

// Assembly:
cmpq %rdx, %rsi
ja 0x7942a
testq %rdi, %rdi
je 0x7942a
movq %rcx, %r9
testq %rcx, %rcx
je 0x7942a
movq %rsi, %rcx
movq (%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x79429
movq %rdx, %r8
leaq 0x8d(%rip), %rdx        # 0x794b4
jmp 0x79430
retq
pushq %rax
callq 0x1c95f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_find_all_internal
static void interval_tree_find_all_internal(GtIntervalTree *it,
                                            GtIntervalTreeNode *node,
                                            GtIntervalTreeIteratorFunc func,
                                            GtUword low,
                                            GtUword high,
                                            void *data)
{
  GtIntervalTreeNode* x;
  if (node == it->nil) return;
  x = node;
  if (low <= x->high && x->low <= high)
    func(node, data);
  /* recursively search left and right subtrees */
  if (x->left != it->nil && low <= x->left->max)
    interval_tree_find_all_internal(it, x->left, func, low, high, data);
  if (x->right != it->nil && low <= x->right->max)
    interval_tree_find_all_internal(it, x->right, func, low, high, data);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x48(%rdi), %rax
cmpq %r13, %rax
je 0x794a5
cmpq %r15, 0x30(%r13)
jb 0x7946f
cmpq %r14, 0x28(%r13)
ja 0x7946f
movq %r13, %rdi
movq %rbx, %rsi
callq *%r12
movq 0x48(%rbp), %rax
movq 0x8(%r13), %rsi
cmpq %rax, %rsi
je 0x79496
cmpq %r15, 0x38(%rsi)
jb 0x79496
movq %rbp, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x79430
movq 0x48(%rbp), %rax
movq 0x10(%r13), %r13
cmpq %rax, %r13
je 0x794a5
cmpq %r15, 0x38(%r13)
jae 0x79451
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_insert
void gt_interval_tree_insert(GtIntervalTree *it, GtIntervalTreeNode *n)
{
  gt_assert(it && n);
  n->parent = it->nil;
  n->left = it->nil;
  n->right = it->nil;
  if (it->root == it->nil)
  {
    it->root = n;
  } else interval_tree_insert_internal(it, &(it->root), n);
  it->size++;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x79691
movq %rsi, %r14
testq %rsi, %rsi
je 0x79691
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq %rax, (%r14)
movq %rax, 0x8(%r14)
movq %rax, 0x10(%r14)
movq (%rdi), %rdi
cmpq %rax, %rdi
je 0x79576
movq 0x28(%r14), %rdx
movq 0x30(%r14), %rcx
movq %rcx, 0x38(%r14)
movq %rdi, %rcx
movq 0x38(%r14), %rsi
cmpq %rsi, 0x38(%rdi)
jae 0x79549
movq %rsi, 0x38(%rcx)
movq 0x28(%rcx), %rsi
xorl %edi, %edi
cmpq %rsi, %rdx
setae %dil
movq 0x8(%rcx,%rdi,8), %rdi
cmpq %rax, %rdi
jne 0x79538
movq %rcx, (%r14)
movq %rbx, %rdi
cmpq %rax, %rcx
je 0x79585
cmpq %rsi, %rdx
jae 0x7957e
addq $0x8, %rcx
jmp 0x79582
movq %r14, (%rbx)
jmp 0x79682
addq $0x10, %rcx
movq %rcx, %rdi
movq %r14, (%rdi)
movl $0x1, 0x20(%r14)
movq (%rbx), %rcx
cmpq %r14, %rcx
je 0x7967b
movq (%r14), %r15
cmpl $0x1, 0x20(%r15)
jne 0x7967b
leaq 0x20(%r15), %rax
xorl %ebp, %ebp
movq (%r15), %rdx
movq 0x8(%rdx), %rcx
cmpq %rcx, %r15
je 0x795d3
cmpq 0x48(%rbx), %rcx
je 0x795c8
cmpl $0x1, 0x20(%rcx)
je 0x795e3
cmpq 0x8(%r15), %r14
je 0x795ff
movq %r15, %rax
jmp 0x79616
movq 0x10(%rdx), %rcx
cmpq 0x48(%rbx), %rcx
je 0x795f4
cmpl $0x1, 0x20(%rcx)
jne 0x795f4
movl %ebp, (%rax)
movl %ebp, 0x20(%rcx)
movl $0x1, 0x20(%rdx)
movq %rdx, %r14
jmp 0x79661
cmpq 0x10(%r15), %r14
je 0x79631
movq %r15, %rax
jmp 0x79648
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7a1cb
movq (%r15), %rax
movq (%rax), %rdx
movq %r15, %r14
movl $0x0, 0x20(%rax)
movl $0x1, 0x20(%rdx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x7a11d
jmp 0x79661
movq %rbx, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x7a11d
movq (%r15), %rax
movq (%rax), %rdx
movq %r15, %r14
movl $0x0, 0x20(%rax)
movl $0x1, 0x20(%rdx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x7a1cb
movq (%rbx), %rcx
cmpq %rcx, %r14
je 0x7967b
movq (%r14), %r15
leaq 0x20(%r15), %rax
cmpl $0x1, 0x20(%r15)
je 0x795b0
movl $0x0, 0x20(%rcx)
incq 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c9d1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_node_rec_delete
static void interval_tree_node_rec_delete(GtIntervalTree *it,
                                          GtIntervalTreeNode *n)
{
  if (n == it->nil) return;
  interval_tree_node_rec_delete(it, n->left);
  interval_tree_node_rec_delete(it, n->right);
  gt_interval_tree_node_delete(it, n);
}

// Assembly:
cmpq %rsi, 0x48(%rdi)
je 0x796f4
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0x796bd
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x796bd
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x79313
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/interval_tree.c
// Function: gt_interval_tree_print_rec
static void gt_interval_tree_print_rec(GtIntervalTree *it,
                                       GtIntervalTreeNode *n)
{
  if (n == it->nil) return;
  printf("(");
  gt_interval_tree_print_rec(it, n->left);
  printf("["GT_WU","GT_WU"]", n->low, n->high);
  gt_interval_tree_print_rec(it, n->right);
  printf(")");
}

// Assembly:
cmpq %rsi, 0x48(%rdi)
je 0x79a1b
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x28, %edi
callq 0xb870
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x799c2
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
leaq 0x77efd(%rip), %rdi     # 0xf18f4
xorl %eax, %eax
callq 0xb070
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x799c2
movl $0x29, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb870
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/interval_tree.c
// Function: range_ptr_compare
static int range_ptr_compare(const void *r1p, const void *r2p)
{
  int ret;
  gt_assert(r1p && r2p);
  ret = gt_range_compare(*(GtRange**) r1p, *(GtRange**) r2p);
  /* It could be that two identical ranges with different pointers are
     present. If so, compare pointers instead to get a canonical ordering. */
  if (ret == 0 && *(GtRange**) r1p != *(GtRange**) r2p)
  {
    if (*(GtRange**) r1p < *(GtRange**) r2p)
      ret = -1;
    else
      ret = 1;
  }
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7a0fd
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7a0fd
movq %rdi, %r14
movq (%rdi), %rdi
movq (%rbx), %rsi
callq 0x7e09c
testl %eax, %eax
jne 0x7a0f5
movq (%r14), %rcx
movq (%rbx), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x7a0f5
cmpq %rdx, %rcx
sbbl %eax, %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1cadb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_left_rotate
static void interval_tree_left_rotate(GtIntervalTree *it,
                                      GtIntervalTreeNode **root,
                                      GtIntervalTreeNode *x)
{
  GtIntervalTreeNode *y;
  y = x->right;
  x->right = y->left;
  if (y->left != it->nil)
    y->left->parent = x;
  y->parent = x->parent;
  if (x->parent == it->nil)
    *root = y;
  else {
    if (x == x->parent->left)
      x->parent->left = y;
    else
      x->parent->right = y;
  }
  y->left = x;
  x->parent = y;
  /* interval tree augmentation */
  x->max = x->high;
  if (x->left != it->nil && x->left->max > x->max)
    x->max = x->left->max;
  if (x->right != it->nil && x->right->max > x->max)
    x->max = x->right->max;
  y->max = y->high;
  if (y->left != it->nil && y->left->max > y->max)
    y->max = y->left->max;
  if (y->right != it->nil && y->right->max > y->max)
    y->max = y->right->max;
}

// Assembly:
movq 0x10(%rdx), %rax
movq 0x8(%rax), %r8
movq %r8, 0x10(%rdx)
movq 0x48(%rdi), %rcx
cmpq %rcx, %r8
je 0x7a135
movq %rdx, (%r8)
movq (%rdx), %r8
movq %r8, (%rax)
cmpq %rcx, %r8
je 0x7a14c
cmpq %rdx, 0x8(%r8)
je 0x7a155
movq %rax, 0x10(%r8)
jmp 0x7a159
movq %rax, (%rsi)
movq 0x48(%rdi), %rcx
jmp 0x7a159
movq %rax, 0x8(%r8)
movq %rdx, 0x8(%rax)
movq %rax, (%rdx)
movq 0x8(%rdx), %rdi
movq 0x30(%rdx), %rsi
movq %rsi, 0x38(%rdx)
cmpq %rcx, %rdi
je 0x7a181
movq 0x38(%rdi), %rdi
cmpq %rsi, %rdi
jbe 0x7a181
movq %rdi, 0x38(%rdx)
movq %rdi, %rsi
movq 0x10(%rdx), %rdi
cmpq %rcx, %rdi
je 0x7a197
movq 0x38(%rdi), %rdi
cmpq %rsi, %rdi
jbe 0x7a197
movq %rdi, 0x38(%rdx)
movq 0x30(%rax), %rsi
movq %rsi, 0x38(%rax)
cmpq %rdx, %rcx
je 0x7a1b4
movq 0x38(%rdx), %rdx
cmpq %rsi, %rdx
jbe 0x7a1b4
movq %rdx, 0x38(%rax)
movq %rdx, %rsi
movq 0x10(%rax), %rdx
cmpq %rcx, %rdx
je 0x7a1ca
movq 0x38(%rdx), %rcx
cmpq %rsi, %rcx
jbe 0x7a1ca
movq %rcx, 0x38(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_right_rotate
static void interval_tree_right_rotate(GtIntervalTree *it,
                                       GtIntervalTreeNode **root,
                                       GtIntervalTreeNode *y)
{
  GtIntervalTreeNode *x;
  x = y->left;
  y->left = x->right;
  if (x->right != it->nil)
    x->right->parent = y;
  x->parent = y->parent;
  if (y->parent == it->nil)
    *root = x;
  else {
    if (y == y->parent->left)
      y->parent->left = x;
    else
      y->parent->right = x;
  }
  x->right = y;
  y->parent = x;
  /* interval tree augmentation */
  x->max = x->high;
  if (x->left != it->nil && x->left->max > x->max)
    x->max = x->left->max;
  if (x->right != it->nil && x->right->max > x->max)
    x->max = x->right->max;
  y->max = y->high;
  if (y->left != it->nil && y->left->max > y->max)
    y->max = y->left->max;
  if (y->right != it->nil && y->right->max > y->max)
    y->max = y->right->max;
}

// Assembly:
movq 0x8(%rdx), %rcx
movq 0x10(%rcx), %r8
movq %r8, 0x8(%rdx)
movq 0x48(%rdi), %rax
cmpq %rax, %r8
je 0x7a1e3
movq %rdx, (%r8)
movq (%rdx), %r8
movq %r8, (%rcx)
cmpq %rax, %r8
je 0x7a1fa
cmpq %rdx, 0x8(%r8)
je 0x7a203
movq %rcx, 0x10(%r8)
jmp 0x7a207
movq %rcx, (%rsi)
movq 0x48(%rdi), %rax
jmp 0x7a207
movq %rcx, 0x8(%r8)
movq %rdx, 0x10(%rcx)
movq %rcx, (%rdx)
movq 0x8(%rcx), %rdi
movq 0x30(%rcx), %rsi
movq %rsi, 0x38(%rcx)
cmpq %rax, %rdi
je 0x7a22f
movq 0x38(%rdi), %rdi
cmpq %rsi, %rdi
jbe 0x7a22f
movq %rdi, 0x38(%rcx)
movq %rdi, %rsi
cmpq %rdx, %rax
je 0x7a241
movq 0x38(%rdx), %rdi
cmpq %rsi, %rdi
jbe 0x7a241
movq %rdi, 0x38(%rcx)
movq 0x8(%rdx), %rsi
movq 0x30(%rdx), %rcx
movq %rcx, 0x38(%rdx)
cmpq %rax, %rsi
je 0x7a262
movq 0x38(%rsi), %rsi
cmpq %rcx, %rsi
jbe 0x7a262
movq %rsi, 0x38(%rdx)
movq %rsi, %rcx
movq 0x10(%rdx), %rsi
cmpq %rax, %rsi
je 0x7a278
movq 0x38(%rsi), %rax
cmpq %rcx, %rax
jbe 0x7a278
movq %rax, 0x38(%rdx)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_double_equals_double
static inline bool gt_double_relative_equal(double d1, double d2)
{
  double relerr;
  if (fabs(d1 - d2) < GT_DBL_MAX_ABS_ERROR)
    return true;
  if (fabs(d2) > fabs(d1))
    relerr = fabs((d1 - d2) / d2);
  else
    relerr = fabs((d1 - d2) / d1);
  if (relerr <= GT_DBL_MAX_REL_ERROR)
    return true;
  return false;
}

// Assembly:
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd 0x72de1(%rip), %xmm3    # 0xed140
andpd %xmm2, %xmm3
movb $0x1, %al
movsd 0x775bb(%rip), %xmm4    # 0xf1928
ucomisd %xmm3, %xmm4
ja 0x7a3b3
movapd 0x72dc5(%rip), %xmm3    # 0xed140
movapd %xmm1, %xmm4
andpd %xmm3, %xmm4
movapd %xmm0, %xmm5
andpd %xmm3, %xmm5
cmpltsd %xmm4, %xmm5
andpd %xmm5, %xmm1
andnpd %xmm0, %xmm5
orpd %xmm1, %xmm5
divsd %xmm5, %xmm2
andpd %xmm3, %xmm2
movsd 0x77584(%rip), %xmm0    # 0xf1930
ucomisd %xmm2, %xmm0
setae %al
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_rand_max
GtUword gt_rand_max(GtUword maximal_value)
{
  GtUword r;
  gt_assert(maximal_value);
  r = ((double) random() / ((double) GT_RAND_MAX + 1) * (maximal_value + 1));
  gt_assert(r <= maximal_value);
  return r;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7a58b
movq %rdi, %rbx
callq 0x3d424
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cvtsi2sd %eax, %xmm0
mulsd 0x773fc(%rip), %xmm0    # 0xf1938
leaq 0x1(%rbx), %rax
movq %rax, %xmm1
punpckldq 0x66f33(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x66f3b(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %rcx
movq %rcx, %rdx
subsd 0x701eb(%rip), %xmm2    # 0xea760
cvttsd2si %xmm2, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
cmpq %rbx, %rax
ja 0x7a590
popq %rbx
retq
callq 0x1cb4b
callq 0x1cb14
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_rand_max_double
double gt_rand_max_double(double maximal_value)
{
  double r;
  gt_assert(maximal_value);
  r = ((double) random() / GT_RAND_MAX) * maximal_value; /* XXX */
  gt_assert(r >= 0.0 && r <= maximal_value);
  return r;
}

// Assembly:
pushq %rax
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp)
ucomisd %xmm1, %xmm0
jne 0x7a5a7
jnp 0x7a5db
callq 0x3d424
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x73388(%rip), %xmm0    # 0xed948
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
ucomisd 0x7736f(%rip), %xmm0    # 0xf1940
jb 0x7a5e0
ucomisd %xmm0, %xmm1
jb 0x7a5e0
popq %rax
retq
callq 0x1cb82
callq 0x1cbb9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_rand_0_to_1
double gt_rand_0_to_1(void)
{
  double r;
  r = (double) random() / GT_RAND_MAX;
  gt_assert(r >= 0.0 && r <= 1.0);
  return r;
}

// Assembly:
pushq %rax
callq 0x3d424
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cvtsi2sd %eax, %xmm0
divsd 0x7334c(%rip), %xmm0    # 0xed948
movsd 0x672ec(%rip), %xmm1    # 0xe18f0
ucomisd %xmm0, %xmm1
jb 0x7a60c
popq %rax
retq
callq 0x1cbf0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_rand_char
char gt_rand_char(void)
{
  int offset;
  char c;
  offset = gt_rand_max(25);
  c = 97 + offset;
  gt_assert(c >= 'a' && c <= 'z');
  return c;
}

// Assembly:
pushq %rax
movl $0x19, %edi
callq 0x7a51d
cmpb $0x1a, %al
jae 0x7a624
addb $0x61, %al
popq %rcx
retq
callq 0x1cc27
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_determinebitspervalue
unsigned int gt_determinebitspervalue(GtUword maxvalue)
{
  unsigned int bits = 0;
#ifndef USEbuiltin_clzl
  GtUword value, mask = (~((GtUword) 0)) << CHAR_BIT;

  for (value = maxvalue; (value & mask) != 0; value >>= CHAR_BIT) {
    bits += CHAR_BIT;
  }
  bits += CHAR_BIT - gt_byte_select[value];
#else
  {
    if (maxvalue != 0) { /*__builtin_clz only defined != 0 */
      bits = (unsigned int) (sizeof(GtUword) * CHAR_BIT) -
             __builtin_clzl(maxvalue);
    }
  }
#endif
  gt_assert(bits <= GT_MAXLOG2VALUE);
  return bits;
}

// Assembly:
pushq %rax
xorl %eax, %eax
cmpq $0x100, %rdi            # imm = 0x100
jae 0x7a63a
movq %rdi, %rcx
jmp 0x7a652
xorl %eax, %eax
movq %rdi, %rcx
addl $0x8, %eax
shrq $0x8, %rcx
cmpq $0xffff, %rdi           # imm = 0xFFFF
movq %rcx, %rdi
ja 0x7a63f
leaq 0x7f057(%rip), %rdx     # 0xf96b0
movzbl (%rdx,%rcx), %ecx
subl %ecx, %eax
addl $0x8, %eax
cmpl $0x40, %eax
jae 0x7a669
popq %rcx
retq
callq 0x1cc5e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_power_for_small_exponents
GtUword gt_power_for_small_exponents(unsigned int base,
                                     unsigned int exponent)
{
  unsigned int logvalue = 0;

  if (exponent == 0) {
    return 1UL;
  }
  switch (base)
  {
    case 2UL:
      logvalue = 1U;
      break;
    case 4UL:
      logvalue = 2U;
      break;
    case 8UL:
      logvalue = 3U;
      break;
    case 16UL:
      logvalue = 4U;
      break;
    case 32UL:
      logvalue = 5U;
      break;
    case 64:
      logvalue = 6U;
      break;
    case 128:
      logvalue = 7U;
      break;
    case 256:
      logvalue = 8U;
      break;
  }
  if (logvalue > 0) {
    gt_assert(logvalue * exponent < sizeof (void *) * 8);
    return 1UL << (logvalue * exponent);
  }
  else {
    GtUword powervalue = (GtUword) base;

    while (exponent > 1U) {
      powervalue *= base;
      exponent--;
    }
    return powervalue;
  }
}

// Assembly:
testl %esi, %esi
je 0x7a692
cmpl $0x1f, %edi
jg 0x7a698
cmpl $0x7, %edi
jg 0x7a6ae
movl $0x1, %ecx
cmpl $0x2, %edi
je 0x7a6e9
cmpl $0x4, %edi
jne 0x7a6fa
movl $0x2, %ecx
jmp 0x7a6e9
movl $0x1, %eax
retq
cmpl $0x7f, %edi
jg 0x7a6bf
cmpl $0x20, %edi
je 0x7a6d6
cmpl $0x40, %edi
jne 0x7a6fa
movl $0x6, %ecx
jmp 0x7a6e9
cmpl $0x8, %edi
je 0x7a6dd
cmpl $0x10, %edi
jne 0x7a6fa
movl $0x4, %ecx
jmp 0x7a6e9
cmpl $0x80, %edi
je 0x7a6e4
cmpl $0x100, %edi            # imm = 0x100
jne 0x7a6fa
movl $0x8, %ecx
jmp 0x7a6e9
movl $0x5, %ecx
jmp 0x7a6e9
movl $0x3, %ecx
jmp 0x7a6e9
movl $0x7, %ecx
imull %esi, %ecx
cmpl $0x40, %ecx
jae 0x7a714
movl $0x1, %eax
shlq %cl, %rax
retq
movl %edi, %ecx
cmpl $0x1, %esi
jne 0x7a705
movq %rcx, %rax
retq
movq %rcx, %rax
imulq %rcx, %rax
decl %esi
cmpl $0x1, %esi
ja 0x7a708
retq
pushq %rax
callq 0x1cc97
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_round_to_long
GtWord gt_round_to_long(double x)
{
  int64_t intgr;
  double rounded = gt_round(x);
  intgr = (int64_t) rounded;
  /* If the fractional part is exactly 0.5, we need to check whether
  the rounded result is even. If it is not we need to add 1 to
  negative values and subtract one from positive values. */
  if ((fabs(((double) intgr) - x) == 0.5) & intgr) {
    /* 1 with the sign of result, i.e. -1 or 1. */
    intgr -= ((intgr >> 62) | ((int64_t) 1));
  }
  return (GtWord) intgr;
}

// Assembly:
pushq %rax
movsd %xmm0, (%rsp)
callq 0xb0e0
movsd (%rsp), %xmm4
xorpd %xmm2, %xmm2
subsd %xmm4, %xmm2
movapd %xmm0, %xmm3
subsd %xmm4, %xmm3
movsd 0x6ff0e(%rip), %xmm1    # 0xea650
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd %xmm1, %xmm3
seta %cl
setae %al
movsd 0x771d0(%rip), %xmm3    # 0xf1928
ucomisd %xmm2, %xmm3
cmoval %ecx, %eax
testb %al, %al
je 0x7a76b
addsd 0x709a5(%rip), %xmm0    # 0xeb110
cvttsd2si %xmm0, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd %xmm4, %xmm0
andpd 0x729bc(%rip), %xmm0    # 0xed140
movl %eax, %ecx
andl $0x1, %ecx
negq %rcx
movq %rax, %rdx
sarq $0x3e, %rdx
orq $0x1, %rdx
andq %rcx, %rdx
xorl %ecx, %ecx
ucomisd %xmm1, %xmm0
cmovneq %rcx, %rdx
cmovpq %rcx, %rdx
subq %rdx, %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_gcd_uint
unsigned int gt_gcd_uint(unsigned int m, unsigned int n)
{
  unsigned int r;

  if (m < n) {
    r = m;
    m = n;
    n = r;
  }
  do {
    gt_assert(m >= n);
    r = m % n;
    m = n;
    n = r;
  } while (r != 0);
  return m;
}

// Assembly:
movl %esi, %edx
cmpl %esi, %edi
movl %esi, %eax
cmoval %edi, %eax
cmovbl %edi, %edx
cmpl %edx, %eax
jb 0x7a7cc
movl %edx, %ecx
xorl %edx, %edx
divl %ecx
movl %ecx, %eax
testl %edx, %edx
jne 0x7a7b9
movl %ecx, %eax
retq
pushq %rax
callq 0x1ccd0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_out_power_for_small_exponents
void gt_out_power_for_small_exponents(void)
{
  unsigned int exponent;

  for (exponent=1U; exponent<64U; exponent++) {
    printf("pow(2UL,%u)="GT_WU"\n",exponent,
            gt_power_for_small_exponents(2U,exponent));
  }
  for (exponent=1U; exponent<32U; exponent++) {
    printf("pow(4UL,%u)="GT_WU"\n",exponent,
            gt_power_for_small_exponents(4U,exponent));
  }
  for (exponent=1U; exponent<16U; exponent++) {
    printf("pow(8UL,%u)="GT_WU"\n",exponent,
            gt_power_for_small_exponents(8U,exponent));
  }
  for (exponent=1U; exponent<32U; exponent++) {
    printf("pow(3UL,%u)="GT_WU"\n",exponent,
            gt_power_for_small_exponents(3U,exponent));
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %ebx
leaq 0x7724c(%rip), %r14     # 0xf1a76
movl $0x2, %edi
movl %ebx, %esi
callq 0x7a66e
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
cmpl $0x40, %ebx
jne 0x7a82a
movl $0x1, %ebx
leaq 0x7722f(%rip), %r14     # 0xf1a87
movl $0x4, %edi
movl %ebx, %esi
callq 0x7a66e
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
cmpl $0x20, %ebx
jne 0x7a858
movl $0x1, %ebx
leaq 0x77212(%rip), %r14     # 0xf1a98
movl $0x8, %edi
movl %ebx, %esi
callq 0x7a66e
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
cmpl $0x10, %ebx
jne 0x7a886
movl $0x1, %ebx
leaq 0x771f5(%rip), %r14     # 0xf1aa9
movl $0x3, %edx
cmpl $0x1, %ebx
je 0x7a8cb
movl %ebx, %eax
leaq (%rdx,%rdx,2), %rdx
decl %eax
cmpl $0x1, %eax
ja 0x7a8c0
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0xb070
incl %ebx
cmpl $0x20, %ebx
jne 0x7a8b4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_seqid.c
// Function: gt_md5_seqid_cmp_seqids
int gt_md5_seqid_cmp_seqids(const char *id_a, const char *id_b)
{
  int md5_status = 0;
  gt_assert(id_a && id_b);

  if (id_a == id_b)
    return 0;
  if (gt_md5_seqid_has_prefix(id_a))
    md5_status += 1;
  if (gt_md5_seqid_has_prefix(id_b))
    md5_status += 2;

  switch (md5_status) {
    case 0:
      return strcmp(id_a, id_b);
    case 1:
      return 1;
    case 2:
      return -1;
    case 3:
      return strncmp(id_a, id_b, GT_MD5_SEQID_TOTAL_LEN);
    default:
      gt_assert(false);   /* cannot happen */
  }
  return 0; /* cannot happen */
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7ab3f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7ab3f
movq %rdi, %r14
cmpq %rbx, %rdi
je 0x7ab0f
leaq 0x770da(%rip), %r15     # 0xf1b8d
movl $0x4, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xb2a0
xorl %r12d, %r12d
testl %eax, %eax
sete %r12b
movl $0x4, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb2a0
movl %eax, %ecx
leal 0x2(%r12), %eax
testl %ecx, %ecx
cmovnel %r12d, %eax
leaq 0x77060(%rip), %rcx     # 0xf1b50
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb890
xorl %eax, %eax
jmp 0x7ab18
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x25, %edx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb2a0
callq 0x1cd79
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/md5_seqid.c
// Function: gt_md5_seqid_unit_test
int gt_md5_seqid_unit_test(GtError *err) {
  int had_err = 0;
  const char *seqid1 = "foo",
             *seqid1_diffptr = "_foo",
             *seqid1_md5 = "md5:d3b07384d113edec49eaa6238ad5ff00:foo",
             *seqid1_wrongmd5 = "md5:c157a79031e1c40f85931829bc5fc552:foo";
  gt_error_check(err);

  gt_ensure(!gt_md5_seqid_has_prefix(seqid1));
  gt_ensure(gt_md5_seqid_has_prefix(seqid1_md5));
  gt_ensure(gt_md5_seqid_cmp_seqids(seqid1, seqid1) == 0);
  gt_ensure(gt_md5_seqid_cmp_seqids(seqid1, seqid1_diffptr+1) == 0);
  gt_ensure(gt_md5_seqid_cmp_seqids(seqid1, seqid1_md5) == -1);
  gt_ensure(gt_md5_seqid_cmp_seqids(seqid1_md5, seqid1) == 1);
  gt_ensure(gt_md5_seqid_cmp_seqids(seqid1_md5, seqid1_md5) == 0);
  gt_ensure(gt_md5_seqid_cmp_seqids(seqid1_md5, seqid1_wrongmd5) > 0);

  return had_err;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x7ab5d
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x7ac6a
leaq 0x7707d(%rip), %rdi     # 0xf1be1
leaq 0x7704d(%rip), %rsi     # 0xf1bb8
callq 0x7aa87
testl %eax, %eax
je 0x7ab9e
leaq 0x685de(%rip), %rsi     # 0xe3159
leaq 0x770a3(%rip), %rdx     # 0xf1c25
leaq 0x77085(%rip), %rcx     # 0xf1c0e
leaq 0x76fe8(%rip), %r8      # 0xf1b78
movq %rbx, %rdi
movl $0x45, %r9d
jmp 0x7ac5c
leaq 0x7703c(%rip), %rdi     # 0xf1be1
leaq 0x77010(%rip), %rsi     # 0xf1bbc
callq 0x7aa87
cmpl $-0x1, %eax
je 0x7abdd
leaq 0x6859c(%rip), %rsi     # 0xe3159
leaq 0x77098(%rip), %rdx     # 0xf1c5c
leaq 0x77043(%rip), %rcx     # 0xf1c0e
leaq 0x76fa6(%rip), %r8      # 0xf1b78
movq %rbx, %rdi
movl $0x46, %r9d
jmp 0x7ac5c
leaq 0x76fd8(%rip), %rdi     # 0xf1bbc
leaq 0x76ff6(%rip), %rsi     # 0xf1be1
callq 0x7aa87
cmpl $0x1, %eax
jne 0x7ac37
leaq 0x76fc0(%rip), %rdi     # 0xf1bbc
leaq 0x76fe2(%rip), %rsi     # 0xf1be5
callq 0x7aa87
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jg 0x7ac68
leaq 0x68542(%rip), %rsi     # 0xe3159
leaq 0x770a1(%rip), %rdx     # 0xf1cbf
leaq 0x76fe9(%rip), %rcx     # 0xf1c0e
leaq 0x76f4c(%rip), %r8      # 0xf1b78
movq %rbx, %rdi
movl $0x49, %r9d
jmp 0x7ac5c
leaq 0x6851b(%rip), %rsi     # 0xe3159
leaq 0x77049(%rip), %rdx     # 0xf1c8e
leaq 0x76fc2(%rip), %rcx     # 0xf1c0e
leaq 0x76f25(%rip), %r8      # 0xf1b78
movq %rbx, %rdi
movl $0x47, %r9d
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
callq 0x1cdb0
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/msort.c
// Function: insertionsort
static void
insertionsort(unsigned char *a, size_t n, size_t size, void *cmpinfo,
              GtCompareWithData cmp)
{
  unsigned char *ai, *s, *t, *u, tmp;
  int i;

  for (ai = a+size; --n >= 1; ai += size)
    for (t = ai; t > a; t -= size) {
      u = t - size;
      if (cmp(u, t, cmpinfo) <= 0)
        break;
      msort_swap(u, t);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
decq %rsi
je 0x7b5bf
movq %rdx, %r15
movq %rdi, %r13
movq %rdx, %rbx
negq %rbx
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x8(%rsp), %r14
leaq (%r14,%r15), %rax
movq %rax, 0x8(%rsp)
cmpq %r13, %rax
jbe 0x7b5b5
movq 0x8(%rsp), %rbp
leaq (%rbx,%rbp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq 0x18(%rsp), %rdx
callq *0x20(%rsp)
testl %eax, %eax
jle 0x7b5b5
xorl %eax, %eax
movb (%r14,%rax), %cl
movb (%rbp,%rax), %dl
movb %dl, (%r14,%rax)
movb %cl, (%rbp,%rax)
incq %rax
cmpl %eax, %r15d
jne 0x7b592
addq %rbx, %r14
movq %r12, %rbp
cmpq %r13, %r12
ja 0x7b579
movq 0x10(%rsp), %rsi
decq %rsi
jne 0x7b55c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/progressbar.c
// Function: gt_progressbar_start
void gt_progressbar_start(GT_UNUSED const GtUint64
                                    *current_computation,
                          GT_UNUSED GtUint64 number_of_computations)
{
#ifndef _WIN32
  computation_counter = current_computation;
  last_computation = number_of_computations;
  computed_eta = 0;
  gt_assert(*current_computation == 0);
  computation_start = gt_xtime(NULL);
  set_window_size();
  if (gt_process_is_foreground())
    refresh_progressbar();
  /* register signal handlers */
  (void) gt_xsignal(SIGALRM, update_progressbar); /* the timer */
  (void) gt_xsignal(SIGWINCH, gt_sig_winch);         /* window resizing */
  (void) alarm(UPDATE_INTERVAL);                  /* set alarm */
#else
  /* XXX */
  fprintf(stderr, "gt_progressbar_start() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0xd75fc(%rip)     # 0x152bd8
movq %rsi, 0xd75fd(%rip)     # 0x152be0
movq $0x0, 0xd75fa(%rip) # 0x152be8
cmpq $0x0, (%rdi)
jne 0x7b68a
xorl %edi, %edi
callq 0x83310
movq %rax, 0xd75ea(%rip)     # 0x152bf0
leaq 0x8(%rsp), %rbx
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb8b0
movzwl 0x2(%rbx), %ecx
movzwl %cx, %ecx
leal 0x1(%rcx), %edx
movl $0x201, %esi            # imm = 0x201
cmpl %esi, %ecx
cmovael %esi, %edx
testw %cx, %cx
movl $0x51, %ecx
cmovel %ecx, %edx
cmpl $-0x1, %eax
cmovel %ecx, %edx
movl %edx, 0xd75b6(%rip)     # 0x152c00
callq 0xa484c
testb %al, %al
je 0x7b658
callq 0x7b68f
leaq 0x40f(%rip), %rsi       # 0x7ba6e
movl $0xe, %edi
callq 0x832e6
leaq 0x4ac(%rip), %rsi       # 0x7bb1c
movl $0x1c, %edi
callq 0x832e6
movl $0x1, %edi
callq 0xbc60
addq $0x10, %rsp
popq %rbx
retq
callq 0x1cde7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/progressbar.c
// Function: update_progressbar
static void update_progressbar(GT_UNUSED int sigraised)
{
  int last_errno = errno;
  gt_assert(sigraised == SIGALRM);
  if (window_resized) {
    set_window_size();
    window_resized = 0;
  }
  if (gt_process_is_foreground())
    refresh_progressbar();
  (void) gt_xsignal(SIGALRM, update_progressbar); /* set signal handler again
                                                     (for systems which switch
                                                     it back to SIG_DFL) */
  (void) alarm(UPDATE_INTERVAL);
  errno = last_errno;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebp
callq 0xb060
cmpl $0xe, %ebp
jne 0x7bb17
movq %rax, %rbx
movl (%rax), %ebp
cmpl $0x0, 0xd7186(%rip)     # 0x152c18
je 0x7bae3
leaq 0x8(%rsp), %r14
movl $0x5413, %esi           # imm = 0x5413
movl $0x1, %edi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb8b0
movzwl 0x2(%r14), %ecx
movzwl %cx, %ecx
leal 0x1(%rcx), %edx
movl $0x201, %esi            # imm = 0x201
cmpl %esi, %ecx
cmovael %esi, %edx
testw %cx, %cx
movl $0x51, %ecx
cmovel %ecx, %edx
cmpl $-0x1, %eax
cmovel %ecx, %edx
movl %edx, 0xd7127(%rip)     # 0x152c00
movl $0x0, 0xd7135(%rip)     # 0x152c18
callq 0xa484c
testb %al, %al
je 0x7baf1
callq 0x7b68f
leaq -0x8a(%rip), %rsi       # 0x7ba6e
movl $0xe, %edi
callq 0x832e6
movl $0x1, %edi
callq 0xbc60
movl %ebp, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1ce20
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/progressbar.c
// Function: gt_progressbar_stop
void gt_progressbar_stop(void)
{
#ifndef _WIN32
  (void) alarm(0); /* reset alarm */
  if (!gt_process_is_foreground())
    return;
  /* ensure the complete bar has been shown */
  if (processed_counter != last_computation) {
    last_computation = *computation_counter;
    refresh_progressbar();
  }
  gt_xwrite(STDOUT_FILENO, "\n", 1); /* trailing newline */
  /* unregister signal handlers */
  (void) gt_xsignal(SIGALRM, SIG_DFL);  /* the timer */
  (void) gt_xsignal(SIGWINCH, SIG_DFL); /* window resizing */
#else
  /* XXX */
  fprintf(stderr, "gt_progressbar_stop() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0xbc60
callq 0xa484c
testb %al, %al
je 0x7bb98
movq 0xd70ae(%rip), %rax     # 0x152bf8
cmpq 0xd708f(%rip), %rax     # 0x152be0
je 0x7bb69
movq 0xd707e(%rip), %rax     # 0x152bd8
movq (%rax), %rax
movq %rax, 0xd707c(%rip)     # 0x152be0
callq 0x7b68f
leaq 0x7bca3(%rip), %rsi     # 0xf7813
movl $0x1, %edx
movl $0x1, %edi
callq 0x8333a
movl $0xe, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x1c, %edi
xorl %esi, %esi
popq %rax
jmp 0x832e6
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/queue.c
// Function: gt_queue_get
void* gt_queue_get(GtQueue *q)
{
  void *contents;
  gt_assert(q && gt_queue_size(q));
  /* get contents */
  contents = q->contents[q->front++];
  /* adjust indices */
  if (q->front == q->back)
    q->front = q->back = 0; /* reset */
  else if (q->front == q->size)
    q->front = 0; /* wraparound */
  return contents;
}

// Assembly:
testq %rdi, %rdi
je 0x7c5ca
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
setle %sil
movq %rcx, %r8
orq %rax, %r8
setne %r8b
testb %r8b, %sil
je 0x7c598
addq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0x7c5ca
leaq 0x8(%rdi), %rdx
movq (%rdi), %r8
leaq 0x1(%rax), %rsi
movq %rsi, 0x8(%rdi)
movq (%r8,%rax,8), %rax
cmpq %rcx, %rsi
jne 0x7c5bc
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
retq
cmpq 0x18(%rdi), %rsi
jne 0x7c5c9
movq $0x0, (%rdx)
retq
pushq %rax
callq 0x1cf00
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/queue.c
// Function: gt_queue_size
GtUword gt_queue_size(const GtQueue *q)
{
  gt_assert(q);
  if ((q->front < q->back) || ((q->front == 0) && (q->back == 0)))
    return q->back - q->front; /* no wraparound */
  return q->size - (q->front - q->back); /* wraparound */
}

// Assembly:
testq %rdi, %rdi
je 0x7c5f7
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
movq %rdx, %rax
subq %rcx, %rax
setle %sil
orq %rcx, %rdx
setne %cl
testb %cl, %sil
je 0x7c5f6
addq 0x18(%rdi), %rax
retq
pushq %rax
callq 0x1cf37
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/queue.c
// Function: gt_queue_iterate
int gt_queue_iterate(GtQueue *q, GtQueueProcessor gt_queue_processor,
                     void *info, GtError *err)
{
  long i;
  int rval;
  gt_error_check(err);
  gt_assert(q && gt_queue_processor);
  if (gt_queue_size(q)) {
    if (q->front < q->back) { /* no wraparound */
      for (i = q->front; i < q->back; i++) {
        if ((rval = gt_queue_processor(q->contents + i, info, err)))
          return rval;
      }
    }
    else { /* wraparound */
      for (i = q->front; i < q->size; i++) {
        if ((rval = gt_queue_processor(q->contents + i, info, err)))
          return rval;
      }
      for (i = 0; i < q->back; i++) {
        if ((rval = gt_queue_processor(q->contents+i, info, err))) return rval;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, (%rsp)
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x7c82b
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x7c922
testq %r12, %r12
je 0x7c91d
testq %r15, %r15
je 0x7c91d
movq 0x8(%r12), %r13
movq 0x10(%r12), %rax
movq %rax, %rcx
subq %r13, %rcx
setle %dl
movq %rax, %rsi
orq %r13, %rsi
setne %sil
testb %sil, %dl
je 0x7c864
addq 0x18(%r12), %rcx
xorl %ebp, %ebp
testq %rcx, %rcx
je 0x7c90c
cmpq %r13, %rax
jle 0x7c8a1
leaq (,%r13,8), %r14
movq (%r12), %rdi
addq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq *%r15
testl %eax, %eax
jne 0x7c90a
incq %r13
addq $0x8, %r14
cmpq 0x10(%r12), %r13
jl 0x7c87c
jmp 0x7c90c
cmpq 0x18(%r12), %r13
jge 0x7c8d8
leaq (,%r13,8), %r14
movq (%r12), %rdi
addq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq *%r15
testl %eax, %eax
jne 0x7c90a
incq %r13
addq $0x8, %r14
cmpq 0x18(%r12), %r13
jl 0x7c8b0
movq 0x10(%r12), %rax
testq %rax, %rax
jle 0x7c90c
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%r12), %rdi
addq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq *%r15
testl %eax, %eax
jne 0x7c90a
incq %r13
addq $0x8, %r14
cmpq 0x10(%r12), %r13
jl 0x7c8e3
xorl %ebp, %ebp
jmp 0x7c90c
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d08b
callq 0x1d052
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/queue.c
// Function: gt_queue_iterate_reverse
int gt_queue_iterate_reverse(GtQueue *q, GtQueueProcessor gt_queue_processor,
                             void *info, GtError *err)
{
  long i;
  int rval;
  gt_error_check(err);
  gt_assert(q && gt_queue_processor);
  if (gt_queue_size(q)) {
    if (q->front < q->back) { /* no wraparound */
      for (i = q->back-1; i >= q->front; i--) {
        if ((rval = gt_queue_processor(q->contents + i, info, err)))
          return rval;
      }
    }
    else { /* wraparound */
      for (i = q->back-1; i >= 0; i--) {
        if ((rval = gt_queue_processor(q->contents + i, info, err)))
          return rval;
      }
      for (i = q->size-1; i >= q->front; i--) {
        if ((rval = gt_queue_processor(q->contents +i, info, err))) return rval;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x7c953
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x7ca42
testq %r12, %r12
je 0x7ca3d
testq %r15, %r15
je 0x7ca3d
movq 0x8(%r12), %rdi
movq 0x10(%r12), %r13
movq %r13, %rcx
subq %rdi, %rcx
setle %dl
movq %r13, %rsi
orq %rdi, %rsi
setne %sil
testb %sil, %dl
je 0x7c98c
addq 0x18(%r12), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x7ca2e
cmpq %rdi, %r13
jle 0x7c9cb
leaq -0x8(,%r13,8), %rdi
incq %r13
decq %r13
cmpq 0x8(%r12), %r13
jle 0x7ca2c
leaq -0x8(%rdi), %rbp
addq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movq %rbp, %rdi
testl %eax, %eax
je 0x7c9a7
jmp 0x7ca2e
leaq -0x8(,%r13,8), %rdi
incq %r13
decq %r13
testq %r13, %r13
jle 0x7c9f8
leaq -0x8(%rdi), %rbp
addq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movq %rbp, %rdi
testl %eax, %eax
je 0x7c9d6
jmp 0x7ca2e
movq 0x18(%r12), %r13
leaq -0x8(,%r13,8), %rdi
incq %r13
decq %r13
cmpq 0x8(%r12), %r13
jle 0x7ca2c
leaq -0x8(%rdi), %rbp
addq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movq %rbp, %rdi
testl %eax, %eax
je 0x7ca08
jmp 0x7ca2e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d0fd
callq 0x1d0c4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/queue.c
// Function: check_queue
static int check_queue(void **elem, void *info, GtError *err)
{
  long *check_counter = info;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(check_counter);
  gt_ensure(*check_counter == *(long*) elem);
  if (!had_err)
    (*check_counter)++;
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x7dfc5
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x7e018
testq %r14, %r14
je 0x7e013
movq (%r14), %rax
cmpq (%r15), %rax
jne 0x7dfdc
incq %rax
movq %rax, (%r14)
xorl %eax, %eax
jmp 0x7e00d
leaq 0x65176(%rip), %rsi     # 0xe3159
leaq 0x74373(%rip), %rdx     # 0xf235d
leaq 0x74352(%rip), %rcx     # 0xf2343
leaq 0x73ffd(%rip), %r8      # 0xf1ff5
movq %rbx, %rdi
movl $0x10a, %r9d            # imm = 0x10A
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d1a8
callq 0x1d16f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/queue.c
// Function: check_queue_reverse
static int check_queue_reverse(void **elem, void *info, GtError *err)
{
  long *check_counter_reverse = info;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(check_counter_reverse);
  gt_ensure(*check_counter_reverse == *(long*) elem);
  if (!had_err)
    (*check_counter_reverse)--;
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x7e03c
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x7e08f
testq %r14, %r14
je 0x7e08a
movq (%r14), %rax
cmpq (%r15), %rax
jne 0x7e053
decq %rax
movq %rax, (%r14)
xorl %eax, %eax
jmp 0x7e084
leaq 0x650ff(%rip), %rsi     # 0xe3159
leaq 0x74346(%rip), %rdx     # 0xf23a7
leaq 0x74315(%rip), %rcx     # 0xf237d
leaq 0x73f86(%rip), %r8      # 0xf1ff5
movq %rbx, %rdi
movl $0x116, %r9d            # imm = 0x116
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d21a
callq 0x1d1e1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_range_compare
int gt_range_compare(const GtRange *range_a, const GtRange *range_b)
{
  gt_assert(range_a->start <= range_a->end && range_b->start <= range_b->end);

  if ((range_a->start == range_b->start) && (range_a->end == range_b->end))
    return 0; /* range_a == range_b */

  if ((range_a->start < range_b->start) ||
      ((range_a->start == range_b->start) && (range_a->end < range_b->end)))
    return -1; /* range_a < range_b */

  return 1; /* range_a > range_b */
}

// Assembly:
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
cmpq %rcx, %rdx
ja 0x7e0e3
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdi
ja 0x7e0e3
movq %rdx, %r8
xorq %rdi, %r8
movq %rcx, %r9
xorq %rsi, %r9
xorl %eax, %eax
orq %r8, %r9
je 0x7e0e2
cmpq %rdi, %rdx
sete %al
setb %dl
cmpq %rsi, %rcx
setb %cl
andb %al, %cl
orb %dl, %cl
movzbl %cl, %eax
negl %eax
orl $0x1, %eax
retq
pushq %rax
callq 0x1d253
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_range_compare_with_delta
int gt_range_compare_with_delta(const GtRange *range_a, const GtRange *range_b,
                                GtUword delta)
{
  GtUword start_min, start_max, end_min, end_max;

  gt_assert(range_a->start <= range_a->end && range_b->start <= range_b->end);

  start_min = GT_MIN(range_a->start, range_b->start);
  start_max = GT_MAX(range_a->start, range_b->start);
  end_min   = GT_MIN(range_a->end, range_b->end);
  end_max   = GT_MAX(range_a->end, range_b->end);

  if (start_max - start_min <= delta && end_max - end_min <= delta)
    return 0; /* range_a == range_b */

  if ((range_a->start < range_b->start) ||
      ((range_a->start == range_b->start) && (range_a->end < range_b->end)))
    return -1; /* range_a < range_b */

  return 1; /* range_a > range_b */
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
ja 0x7e15a
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdi
ja 0x7e15a
movq %rcx, %r8
subq %rdi, %r8
sete %r9b
negq %r8
movq %rcx, %r10
subq %rdi, %r10
cmovbeq %r8, %r10
movq %rax, %r8
subq %rsi, %r8
setb %r11b
negq %r8
subq %rsi, %rax
cmovbeq %r8, %rax
cmpq %rdx, %r10
setbe %sil
cmpq %rdx, %rax
setbe %al
andb %sil, %al
movzbl %al, %edx
leal -0x1(%rdx), %esi
andb %r9b, %r11b
movzbl %r11b, %eax
negl %eax
orl $0x1, %eax
testb %dl, %dl
cmovnel %esi, %eax
cmpq %rdi, %rcx
cmovbl %esi, %eax
retq
pushq %rax
callq 0x1d28a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_range_compare_by_length_ptr
int gt_range_compare_by_length_ptr(const GtRange *range_a,
                                   const GtRange *range_b)
{
  GtUword range_a_length, range_b_length;
  gt_assert(range_a && range_b);
  range_a_length = gt_range_length(range_a);
  range_b_length = gt_range_length(range_b);
  if (range_a_length == range_b_length)
    return 0;
  if (range_a_length > range_b_length)
    return -1;
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7e19a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7e19a
callq 0x7e19f
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e19f
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rax, %r14
setbe %dl
leal -0x1(%rdx,%rdx), %eax
cmovel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1d2c1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_range_overlap_delta
bool gt_range_overlap_delta(const GtRange *range_a, const GtRange *range_b,
                            GtUword delta)
{
  GtUword range_a_length, range_b_length;
  gt_assert(range_a->start <= range_a->end && range_b->start <= range_b->end);

  range_a_length = range_a->end - range_a->start + 1;
  range_b_length = range_b->end - range_b->start + 1;

  if (range_a_length < delta || range_b_length < delta) {
    /* no overlap of delta possible */
    return false;
  }

  if (gt_range_overlap(range_a, range_b)) {
    if (range_a->start <= range_b->start) {
      if (range_a->end >= range_b->end) {
        /* ----A----
            ---B---  */
        if (range_b_length >= delta)
          return true;
      }
      else { /* range_a->end < range_b->end */
        /* ----A----
            ----B---- */
        if (range_a->end - range_b->start + 1 >= delta)
          return true;
      }
    }
    else { /* range_a->start > range_b->start */
      if (range_a->end <= range_b->end) {
        /*  ---A---
           ----B---- */
        if (range_a_length >= delta)
          return true;
      }
      else { /* range_a->end > range_b->end */
        /*  ----A----
           ----B----  */
        if (range_b->end - range_a->start + 1 >= delta)
          return true;
      }
    }
  }

  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rcx
subq (%rdi), %rcx
jb 0x7e25c
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
jb 0x7e25c
incq %rcx
xorl %eax, %eax
cmpq %rbx, %rcx
jb 0x7e256
incq %rdx
cmpq %rbx, %rdx
jb 0x7e256
movq %rdi, %r15
movq %r14, %rsi
callq 0x7e1b2
testb %al, %al
je 0x7e254
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movb $0x1, %al
cmpq %rdi, %rsi
jbe 0x7e244
cmpq %rdx, %rcx
jbe 0x7e256
subq %rsi, %rdx
incq %rdx
cmpq %rbx, %rdx
jb 0x7e254
jmp 0x7e256
cmpq %rdx, %rcx
jae 0x7e256
subq %rdi, %rcx
incq %rcx
cmpq %rbx, %rcx
jae 0x7e256
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d368
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_range_join
GtRange gt_range_join(const GtRange *range_a, const GtRange *range_b)
{
  GtRange r;

  gt_assert(range_a->start <= range_a->end && range_b->start <= range_b->end);

  r.start = range_a->start < range_b->start ? range_a->start : range_b->start;
  r.end   = range_a->end   > range_b->end   ? range_a->end   : range_b->end;

  return r;
}

// Assembly:
movq (%rdi), %r8
movq 0x8(%rdi), %rcx
cmpq %rcx, %r8
ja 0x7e2d6
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
cmpq %rdx, %rax
ja 0x7e2d6
cmpq %rax, %r8
cmovbq %r8, %rax
cmpq %rdx, %rcx
cmovaq %rcx, %rdx
retq
pushq %rax
callq 0x1d411
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_range_offset
GtRange gt_range_offset(const GtRange *range, GtWord offset)
{
  GtRange transformed_range = { 0, 0 };
  gt_assert(range->start <= range->end);
  gt_safe_add(transformed_range.start, range->start, offset);
  gt_safe_add(transformed_range.end, range->end, offset);
  gt_assert(transformed_range.start <= transformed_range.end);
  return transformed_range;
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
cmpq %rdx, %rax
ja 0x7e318
movq %rsi, %rcx
testq %rsi, %rsi
jle 0x7e303
notq %rcx
cmpq %rcx, %rax
ja 0x7e31d
cmpq %rcx, %rdx
jbe 0x7e30b
callq 0x1d44a
negq %rcx
cmpq %rcx, %rax
jb 0x7e31d
addq %rsi, %rdx
addq %rsi, %rax
cmpq %rdx, %rax
ja 0x7e322
popq %rcx
retq
callq 0x1d4dd
callq 0x1d4b0
callq 0x1d477
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_are_sorted
bool gt_ranges_are_sorted(const GtArray *ranges)
{
  GtUword i;

  gt_assert(ranges);

  for (i = 1; i < gt_array_size(ranges); i++) {
    if (gt_range_compare(gt_array_get(ranges, i-1),
                         gt_array_get(ranges, i)) == 1) {
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7eb07
movq %rdi, %rbx
callq 0x6f310
movb $0x1, %bpl
cmpq $0x2, %rax
jb 0x7eafa
movl $0x1, %r14d
leaq -0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x6f037
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6f037
movq %r15, %rdi
movq %rax, %rsi
callq 0x7e09c
cmpl $0x1, %eax
setne %bpl
je 0x7eafa
incq %r14
movq %rbx, %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x7eabc
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d6a5