LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x8ad80
jmp 0x8ade2
leaq 0xe40b9(%rip), %rdi     # 0x16ee40
movb $0x0, %al
callq 0xb070
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x8ad60
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdx
leaq 0xe4088(%rip), %rdi     # 0x16ee42
movb $0x0, %al
callq 0xb070
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x8ad60
leaq 0xe1e13(%rip), %rdi     # 0x16cbee
movb $0x0, %al
callq 0xb070
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x8ba9e
cmpq $0x0, 0x8(%rsp)
jne 0x8bad6
movq 0x128533(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd25b7(%rip), %rsi     # 0x15e066
leaq 0xe3396(%rip), %rdx     # 0x16ee4c
leaq 0xe339a(%rip), %rcx     # 0x16ee57
leaq 0xe30f5(%rip), %r8      # 0x16ebb9
movl $0x20c, %r9d            # imm = 0x20C
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8bad8
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x93850
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x8bb30
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
je 0x8bb30
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x8bb26
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x8bb2e
movl $0x1, 0x4(%rsp)
jmp 0x8bb30
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/interval_tree.c
// Function: interval_tree_insert
static void interval_tree_insert(GtIntervalTree *it,
                                 GtIntervalTreeNode **root,
                                 GtIntervalTreeNode *z)
{
  GtIntervalTreeNode *x, *y;
  y = it->nil;
  x = *root;
  z->max = z->high;
  while (x != it->nil)
  {
    y = x;
    /* interval tree augmentation */
    if (x->max < z->max)
      x->max = z->max;
    if (z->low < x->low)
      x = x->left;
    else
      x = x->right;
  }
  z->parent = y;
  if (y == it->nil)
    *root = z;
  else
  {
    if (z->low < y->low)
      y->left = z;
    else
      y->right = z;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x30(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
je 0x8bc30
movq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x8bbfc
movq -0x18(%rsp), %rax
movq 0x38(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x8bc20
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x8bc2e
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x8bbbc
movq -0x28(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x28(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jne 0x8bc5c
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x8bc90
movq -0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq -0x28(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x8bc80
movq -0x18(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x8bc8e
movq -0x18(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x8bc90
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_double_relative_equal
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:
movsd %xmm0, -0x10(%rsp)
movsd %xmm1, -0x18(%rsp)
movsd -0x10(%rsp), %xmm1
subsd -0x18(%rsp), %xmm1
movaps 0xdead1(%rip), %xmm0    # 0x16acf0
pand %xmm0, %xmm1
movsd 0xe2c45(%rip), %xmm0    # 0x16ee70
ucomisd %xmm1, %xmm0
jbe 0x8c23b
movb $0x1, -0x1(%rsp)
jmp 0x8c2c7
movsd -0x18(%rsp), %xmm0
movaps 0xdeaa8(%rip), %xmm1    # 0x16acf0
pand %xmm1, %xmm0
movsd -0x10(%rsp), %xmm1
movaps 0xdea97(%rip), %xmm2    # 0x16acf0
pand %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8c288
movsd -0x10(%rsp), %xmm0
subsd -0x18(%rsp), %xmm0
divsd -0x18(%rsp), %xmm0
movaps 0xdea74(%rip), %xmm1    # 0x16acf0
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
jmp 0x8c2ab
movsd -0x10(%rsp), %xmm0
subsd -0x18(%rsp), %xmm0
divsd -0x10(%rsp), %xmm0
movaps 0xdea4f(%rip), %xmm1    # 0x16acf0
pand %xmm1, %xmm0
movsd %xmm0, -0x20(%rsp)
movsd 0xe2bc5(%rip), %xmm0    # 0x16ee78
ucomisd -0x20(%rsp), %xmm0
jb 0x8c2c2
movb $0x1, -0x1(%rsp)
jmp 0x8c2c7
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_double_compare
int gt_double_compare(double d1, double d2)
{
  if (gt_double_relative_equal(d1, d2))
    return 0;
  if (d1 > d2)
    return 1;
  return -1;
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x8c200
testb $0x1, %al
jne 0x8c325
jmp 0x8c32f
movl $0x0, 0x14(%rsp)
jmp 0x8c34e
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jbe 0x8c346
movl $0x1, 0x14(%rsp)
jmp 0x8c34e
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x8c409
movq 0x127c00(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd1c84(%rip), %rsi     # 0x15e066
leaq 0xe2b2e(%rip), %rdx     # 0x16ef17
leaq 0xe2ae0(%rip), %rcx     # 0x16eed0
leaq 0xe2ae5(%rip), %r8      # 0x16eedc
movl $0x58, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8c40b
callq 0x1cd80
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cvtsi2sd %eax, %xmm0
movsd 0xe2a5f(%rip), %xmm1    # 0x16ee80
mulsd %xmm1, %xmm0
movq 0x10(%rsp), %rax
incq %rax
movq %rax, %xmm1
movaps 0xd2047(%rip), %xmm2    # 0x15e480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0xd204b(%rip), %xmm2    # 0x15e490
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0xdb4b9(%rip), %xmm1    # 0x167928
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jbe 0x8c4c7
movq 0x127b42(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd1bc6(%rip), %rsi     # 0x15e066
leaq 0xe2a6b(%rip), %rdx     # 0x16ef12
leaq 0xe2a22(%rip), %rcx     # 0x16eed0
leaq 0xe2a27(%rip), %r8      # 0x16eedc
movl $0x5a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8c4c9
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x8c533
jp 0x8c533
movq 0x127ad6(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd1b5a(%rip), %rsi     # 0x15e066
leaq 0xe2a04(%rip), %rdx     # 0x16ef17
leaq 0xe29d9(%rip), %rcx     # 0x16eef3
leaq 0xe29bb(%rip), %r8      # 0x16eedc
movl $0x61, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8c535
callq 0x1cd80
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd 0xde792(%rip), %xmm1    # 0x16ace0
divsd %xmm1, %xmm0
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x8c57f
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x8c5b7
movq 0x127a52(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd1ad6(%rip), %rsi     # 0x15e066
leaq 0xe296f(%rip), %rdx     # 0x16ef06
leaq 0xe2955(%rip), %rcx     # 0x16eef3
leaq 0xe2937(%rip), %r8      # 0x16eedc
movl $0x63, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8c5b9
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x8c3c0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
addl $0x61, %eax
movb %al, 0x3(%rsp)
movsbl 0x3(%rsp), %eax
cmpl $0x61, %eax
jl 0x8c68e
movsbl 0x3(%rsp), %eax
cmpl $0x7a, %eax
jle 0x8c6c6
movq 0x127943(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd19c7(%rip), %rsi     # 0x15e066
leaq 0xe28a3(%rip), %rdx     # 0x16ef49
leaq 0xe28b1(%rip), %rcx     # 0x16ef5e
leaq 0xe2828(%rip), %r8      # 0x16eedc
movl $0x75, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8c6c8
movb 0x3(%rsp), %al
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq $-0x100, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
andq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x8c71f
movl 0x1c(%rsp), %eax
addl $0x8, %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x8c6f4
movq 0x10(%rsp), %rcx
leaq 0xeb3c5(%rip), %rax     # 0x177af0
movzbl (%rax,%rcx), %ecx
movl $0x8, %eax
subl %ecx, %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpl $0x3f, 0x1c(%rsp)
jbe 0x8c77d
movq 0x12788c(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd1910(%rip), %rsi     # 0x15e066
leaq 0xe280e(%rip), %rdx     # 0x16ef6b
leaq 0xe281f(%rip), %rcx     # 0x16ef83
leaq 0xe2771(%rip), %r8      # 0x16eedc
movl $0x90, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8c77f
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl %esi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpl $0x0, 0x18(%rsp)
jne 0x8c7b9
movq $0x1, 0x20(%rsp)
jmp 0x8c90d
movl 0x1c(%rsp), %eax
movl %eax, 0x4(%rsp)
subl $0x2, %eax
je 0x8c819
jmp 0x8c7c8
movl 0x4(%rsp), %eax
subl $0x4, %eax
je 0x8c823
jmp 0x8c7d3
movl 0x4(%rsp), %eax
subl $0x8, %eax
je 0x8c82d
jmp 0x8c7de
movl 0x4(%rsp), %eax
subl $0x10, %eax
je 0x8c837
jmp 0x8c7e9
movl 0x4(%rsp), %eax
subl $0x20, %eax
je 0x8c841
jmp 0x8c7f4
movl 0x4(%rsp), %eax
subl $0x40, %eax
je 0x8c84b
jmp 0x8c7ff
movl 0x4(%rsp), %eax
subl $0x80, %eax
je 0x8c855
jmp 0x8c80c
movl 0x4(%rsp), %eax
subl $0x100, %eax            # imm = 0x100
je 0x8c85f
jmp 0x8c867
movl $0x1, 0x14(%rsp)
jmp 0x8c867
movl $0x2, 0x14(%rsp)
jmp 0x8c867
movl $0x3, 0x14(%rsp)
jmp 0x8c867
movl $0x4, 0x14(%rsp)
jmp 0x8c867
movl $0x5, 0x14(%rsp)
jmp 0x8c867
movl $0x6, 0x14(%rsp)
jmp 0x8c867
movl $0x7, 0x14(%rsp)
jmp 0x8c867
movl $0x8, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jbe 0x8c8d7
jmp 0x8c870
movl 0x14(%rsp), %eax
imull 0x18(%rsp), %eax
movl %eax, %eax
cmpq $0x40, %rax
jb 0x8c8b9
movq 0x127750(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd17d4(%rip), %rsi     # 0x15e066
leaq 0xe2703(%rip), %rdx     # 0x16ef9c
leaq 0xe2726(%rip), %rcx     # 0x16efc6
leaq 0xe2635(%rip), %r8      # 0x16eedc
movl $0xb8, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8c8bb
movl 0x14(%rsp), %eax
imull 0x18(%rsp), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x20(%rsp)
jmp 0x8c90d
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
cmpl $0x1, 0x18(%rsp)
jbe 0x8c903
movl 0x1c(%rsp), %eax
imulq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x8c8e0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/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:
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x8c9b0
movsd %xmm0, (%rsp)
cvttsd2si (%rsp), %rax
movq %rax, 0x8(%rsp)
cvtsi2sdq 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
movaps 0xde397(%rip), %xmm1    # 0x16acf0
pand %xmm1, %xmm0
movsd 0xdaeb3(%rip), %xmm1    # 0x167818
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
cltq
andq 0x8(%rsp), %rax
cmpq $0x0, %rax
je 0x8c99d
movq 0x8(%rsp), %rcx
sarq $0x3e, %rcx
orq $0x1, %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/mathsupport.c
// Function: gt_round
static inline double gt_round(double x)
{
  double integer = ceil(x);
  if (0.0 - x < GT_DBL_MAX_ABS_ERROR)
    return integer - x > 0.5 ? integer - 1.0 : integer;
  return integer - x >= 0.5 ? integer - 1.0 : integer;
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0xb0d0
movsd %xmm0, 0x10(%rsp)
xorps %xmm1, %xmm1
subsd 0x18(%rsp), %xmm1
movsd 0xe2494(%rip), %xmm0    # 0x16ee70
ucomisd %xmm1, %xmm0
jbe 0x8ca30
movsd 0x10(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
movsd 0xdae22(%rip), %xmm1    # 0x167818
ucomisd %xmm1, %xmm0
jbe 0x8ca16
movsd 0x10(%rsp), %xmm0
movsd 0xd1dfe(%rip), %xmm1    # 0x15e808
subsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x8ca22
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x8ca79
movsd 0x10(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
movsd 0xdadd4(%rip), %xmm1    # 0x167818
ucomisd %xmm1, %xmm0
jb 0x8ca63
movsd 0x10(%rsp), %xmm0
movsd 0xd1db0(%rip), %xmm1    # 0x15e808
subsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
jmp 0x8ca6e
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jae 0x8cabe
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x8cac0
jmp 0x8cac2
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jae 0x8cb04
movq 0x127505(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd1589(%rip), %rsi     # 0x15e066
leaq 0xe24ff(%rip), %rdx     # 0x16efe3
leaq 0xe24ff(%rip), %rcx     # 0x16efea
leaq 0xe23ea(%rip), %r8      # 0x16eedc
movl $0xe7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8cb06
movl 0x14(%rsp), %eax
xorl %edx, %edx
divl 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x8cac0
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl $0x1, 0x14(%rsp)
cmpl $0x40, 0x14(%rsp)
jae 0x8cc0b
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %esi
movl $0x2, %edi
callq 0x8c790
movl 0x10(%rsp), %esi
movq %rax, %rdx
leaq 0xe23ff(%rip), %rdi     # 0x16eff6
movb $0x0, %al
callq 0xb070
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8cbcc
movl $0x1, 0x14(%rsp)
cmpl $0x20, 0x14(%rsp)
jae 0x8cc52
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %esi
movl $0x4, %edi
callq 0x8c790
movl 0xc(%rsp), %esi
movq %rax, %rdx
leaq 0xe23c9(%rip), %rdi     # 0x16f007
movb $0x0, %al
callq 0xb070
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8cc13
movl $0x1, 0x14(%rsp)
cmpl $0x10, 0x14(%rsp)
jae 0x8cc99
movl 0x14(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x14(%rsp), %esi
movl $0x8, %edi
callq 0x8c790
movl 0x8(%rsp), %esi
movq %rax, %rdx
leaq 0xe2393(%rip), %rdi     # 0x16f018
movb $0x0, %al
callq 0xb070
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8cc5a
movl $0x1, 0x14(%rsp)
cmpl $0x20, 0x14(%rsp)
jae 0x8cce0
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x14(%rsp), %esi
movl $0x3, %edi
callq 0x8c790
movl 0x4(%rsp), %esi
movq %rax, %rdx
leaq 0xe235d(%rip), %rdi     # 0x16f029
movb $0x0, %al
callq 0xb070
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8cca1
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x8dd36
cmpq $0x0, 0x10(%rsp)
jne 0x8dd6e
movq 0x12629b(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd031f(%rip), %rsi     # 0x15e066
leaq 0xe197c(%rip), %rdx     # 0x16f6ca
leaq 0xe1982(%rip), %rcx     # 0x16f6d7
leaq 0xe1954(%rip), %r8      # 0x16f6b0
movl $0x22, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8dd70
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0x8dd89
movl $0x0, 0x24(%rsp)
jmp 0x8de5e
movq 0x18(%rsp), %rdi
callq 0x8dca0
testb $0x1, %al
jne 0x8dd99
jmp 0x8dda4
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x8dca0
testb $0x1, %al
jne 0x8ddb4
jmp 0x8ddbf
movl 0xc(%rsp), %eax
addl $0x2, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq %rax, (%rsp)
subq $0x3, %rax
ja 0x8de24
movq (%rsp), %rax
leaq 0xe18b0(%rip), %rcx     # 0x16f688
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb850
movl %eax, 0x24(%rsp)
jmp 0x8de5e
movl $0x1, 0x24(%rsp)
jmp 0x8de5e
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x8de5e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x25, %edx
callq 0xb280
movl %eax, 0x24(%rsp)
jmp 0x8de5e
jmp 0x8de26
movq 0x1261ab(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xd022f(%rip), %rsi     # 0x15e066
leaq 0xe4f28(%rip), %rdx     # 0x172d66
leaq 0xe1892(%rip), %rcx     # 0x16f6d7
leaq 0xe1864(%rip), %r8      # 0x16f6b0
movl $0x35, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
addq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x48(%rsp)
cmpq $0x1, %rax
jb 0x8f2ba
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x50(%rsp), %rax
jbe 0x8f2a4
movq 0x18(%rsp), %rax
xorl %ecx, %ecx
subq 0x40(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq *%rax
cmpl $0x0, %eax
jg 0x8f212
jmp 0x8f2a4
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movb (%rax), %al
movb %al, 0xf(%rsp)
movq 0x20(%rsp), %rax
movb (%rax), %cl
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb %cl, (%rax)
movb 0xf(%rsp), %cl
movq 0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rsp)
movb %cl, (%rax)
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, %eax
jne 0x8f225
movq 0x40(%rsp), %rdx
movq 0x10(%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdx
movq 0x18(%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
jmp 0x8f1ce
jmp 0x8f2a6
movq 0x40(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x8f1ac
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x1271de(%rip)    # 0x1b64b8
movq 0x8(%rsp), %rax
movq %rax, 0x1271da(%rip)    # 0x1b64c0
movq $0x0, 0x1271d7(%rip) # 0x1b64c8
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x8f334
movq 0x124cd5(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xced59(%rip), %rsi     # 0x15e066
leaq 0xe05d4(%rip), %rdx     # 0x16f8e8
leaq 0xe05e7(%rip), %rcx     # 0x16f902
leaq 0xe05f5(%rip), %r8      # 0x16f917
movl $0xd0, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8f336
xorl %eax, %eax
movl %eax, %edi
callq 0xa30a0
movq %rax, 0x12718a(%rip)    # 0x1b64d0
callq 0x8f390
callq 0xe1e70
testb $0x1, %al
jne 0x8f356
jmp 0x8f35b
callq 0x8f400
movl $0xe, %edi
leaq 0x829(%rip), %rsi       # 0x8fb90
callq 0xa2fd0
movl $0x1c, %edi
leaq 0x8d8(%rip), %rsi       # 0x8fc50
callq 0xa2fd0
movl $0x1, %edi
callq 0xbc20
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/progressbar.c
// Function: set_window_size
static void set_window_size(void)
{
  struct winsize winsize;
  if (ioctl(STDOUT_FILENO, (GtUword) TIOCGWINSZ, &winsize) != -1 &&
      winsize.ws_col != 0) {
    if ((int) winsize.ws_col > MAXIMUM_WINDOW_SIZE)
      window_size = MAXIMUM_WINDOW_SIZE;
    else
      window_size = (int) winsize.ws_col;
  }
  else
    window_size = DEFAULT_WINDOW_SIZE;
  window_size += 1; /* for the trailing '\0' */
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x5413, %esi           # imm = 0x5413
movq %rsp, %rdx
movb $0x0, %al
callq 0xb870
cmpl $-0x1, %eax
je 0x8f3d9
movzwl 0x2(%rsp), %eax
cmpl $0x0, %eax
je 0x8f3d9
movzwl 0x2(%rsp), %eax
cmpl $0x200, %eax            # imm = 0x200
jle 0x8f3cc
movl $0x200, 0x127116(%rip)  # imm = 0x200
jmp 0x8f3d7
movzwl 0x2(%rsp), %eax
movl %eax, 0x127109(%rip)    # 0x1b64e0
jmp 0x8f3e3
movl $0x50, 0x1270fd(%rip)   # 0x1b64e0
movl 0x1270f7(%rip), %eax    # 0x1b64e0
addl $0x1, %eax
movl %eax, 0x1270ee(%rip)    # 0x1b64e0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
callq 0xb060
movl (%rax), %eax
movl %eax, 0x10(%rsp)
cmpl $0xe, 0x14(%rsp)
je 0x8fbe2
movq 0x124427(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xce4ab(%rip), %rsi     # 0x15e066
leaq 0xdffc7(%rip), %rdx     # 0x16fb89
leaq 0xdffd5(%rip), %rcx     # 0x16fb9e
leaq 0xdfd47(%rip), %r8      # 0x16f917
movl $0xb3, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x8fbe4
movl 0x12690e(%rip), %eax    # 0x1b64f8
cmpl $0x0, %eax
je 0x8fbfe
callq 0x8f390
movl $0x0, 0x1268fa(%rip)    # 0x1b64f8
callq 0xe1e70
testb $0x1, %al
jne 0x8fc09
jmp 0x8fc0e
callq 0x8f400
movl $0xe, %edi
leaq -0x8a(%rip), %rsi       # 0x8fb90
callq 0xa2fd0
movl $0x1, %edi
callq 0xbc20
movl 0x10(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xb060
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0xbc20
callq 0xe1e70
testb $0x1, %al
jne 0x8fcc3
jmp 0x8fd1b
movq 0x12680e(%rip), %rax    # 0x1b64d8
cmpq 0x1267ef(%rip), %rax    # 0x1b64c0
je 0x8fce9
movq 0x1267de(%rip), %rax    # 0x1b64b8
movq (%rax), %rax
movq %rax, 0x1267dc(%rip)    # 0x1b64c0
callq 0x8f400
movl $0x1, %edi
leaq 0xe5ef0(%rip), %rsi     # 0x175be5
movl $0x1, %edx
callq 0xa3150
movl $0xe, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
movl $0x1c, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0xa2fd0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x90c71
movq 0x10(%rsp), %rdi
callq 0x90d30
cmpq $0x0, %rax
jne 0x90ca9
movq 0x123360(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xcd3e4(%rip), %rsi     # 0x15e066
leaq 0xdef69(%rip), %rdx     # 0x16fbf2
leaq 0xdef78(%rip), %rcx     # 0x16fc08
leaq 0xdef3d(%rip), %r8      # 0x16fbd4
movl $0x6c, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x90cab
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x90d00
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x90d23
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x90d21
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x90d23
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x90d79
movq 0x123290(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xcd314(%rip), %rsi     # 0x15e066
leaq 0xe205e(%rip), %rdx     # 0x172db7
leaq 0xdef29(%rip), %rcx     # 0x16fc89
leaq 0xdee6d(%rip), %r8      # 0x16fbd4
movl $0xe7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x90d7b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jl 0x90da7
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x90dc0
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x90dc0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
subq 0x8(%rcx), %rax
movq %rax, 0x10(%rsp)
jmp 0x90de3
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rsp), %rdx
subq 0x10(%rdx), %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/queue.c
// Function: queue_wrap
static void queue_wrap(GtQueue *q, bool free_contents)
{
  gt_assert(q);
  if (free_contents) {
    while (gt_queue_size(q))
      gt_free(gt_queue_get(q));
  }
  gt_free(q->contents);
  gt_free(q);
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x917e2
movq 0x122827(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xcc8ab(%rip), %rsi     # 0x15e066
leaq 0xe15f5(%rip), %rdx     # 0x172db7
leaq 0xde759(%rip), %rcx     # 0x16ff22
leaq 0xde404(%rip), %r8      # 0x16fbd4
movl $0xef, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x917e4
testb $0x1, 0xf(%rsp)
je 0x9181f
jmp 0x917ed
movq 0x10(%rsp), %rdi
callq 0x90d30
cmpq $0x0, %rax
je 0x9181d
movq 0x10(%rsp), %rdi
callq 0x90c50
movq %rax, %rdi
leaq 0xde3c3(%rip), %rsi     # 0x16fbd4
movl $0xf2, %edx
callq 0xdab0
jmp 0x917ed
jmp 0x9181f
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0xde3a6(%rip), %rsi     # 0x16fbd4
movl $0xf4, %edx
callq 0xdab0
movq 0x10(%rsp), %rdi
leaq 0xde390(%rip), %rsi     # 0x16fbd4
movl $0xf5, %edx
callq 0xdab0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x93645
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x9360d
jmp 0x93645
movq 0x1209c4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xcaa48(%rip), %rsi     # 0x15e066
leaq 0xcb023(%rip), %rdx     # 0x15e648
leaq 0xdc901(%rip), %rcx     # 0x16ff2d
leaq 0xdc5a1(%rip), %r8      # 0x16fbd4
movl $0x108, %r9d            # imm = 0x108
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x93647
jmp 0x93649
cmpq $0x0, 0x8(%rsp)
jne 0x93689
movq 0x120980(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xcaa04(%rip), %rsi     # 0x15e066
leaq 0xdc8d0(%rip), %rdx     # 0x16ff39
leaq 0xdc8bd(%rip), %rcx     # 0x16ff2d
leaq 0xdc55d(%rip), %r8      # 0x16fbd4
movl $0x109, %r9d            # imm = 0x109
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9368b
jmp 0x9368d
cmpl $0x0, 0x4(%rsp)
jne 0x936de
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
je 0x936dc
movq 0x10(%rsp), %rdi
leaq 0xccac5(%rip), %rsi     # 0x160177
leaq 0xdc88e(%rip), %rdx     # 0x16ff47
leaq 0xdc86d(%rip), %rcx     # 0x16ff2d
leaq 0xdc50d(%rip), %r8      # 0x16fbd4
movl $0x10a, %r9d            # imm = 0x10A
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x936de
jmp 0x936e0
cmpl $0x0, 0x4(%rsp)
jne 0x936f6
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x93775
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x9373d
jmp 0x93775
movq 0x120894(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xca918(%rip), %rsi     # 0x15e066
leaq 0xcaef3(%rip), %rdx     # 0x15e648
leaq 0xdc80b(%rip), %rcx     # 0x16ff67
leaq 0xdc471(%rip), %r8      # 0x16fbd4
movl $0x114, %r9d            # imm = 0x114
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x93777
jmp 0x93779
cmpq $0x0, 0x8(%rsp)
jne 0x937b9
movq 0x120850(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xca8d4(%rip), %rsi     # 0x15e066
leaq 0xdc7e2(%rip), %rdx     # 0x16ff7b
leaq 0xdc7c7(%rip), %rcx     # 0x16ff67
leaq 0xdc42d(%rip), %r8      # 0x16fbd4
movl $0x115, %r9d            # imm = 0x115
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x937bb
jmp 0x937bd
cmpl $0x0, 0x4(%rsp)
jne 0x9380e
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
je 0x9380c
movq 0x10(%rsp), %rdi
leaq 0xcc995(%rip), %rsi     # 0x160177
leaq 0xdc7a8(%rip), %rdx     # 0x16ff91
leaq 0xdc777(%rip), %rcx     # 0x16ff67
leaq 0xdc3dd(%rip), %r8      # 0x16fbd4
movl $0x116, %r9d            # imm = 0x116
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x9380e
jmp 0x93810
cmpl $0x0, 0x4(%rsp)
jne 0x93826
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x93881
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x938b9
movq 0x120750(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xca7d4(%rip), %rsi     # 0x15e066
leaq 0xdc720(%rip), %rdx     # 0x16ffb9
leaq 0xdc75a(%rip), %rcx     # 0x16fffa
leaq 0xdc764(%rip), %r8      # 0x17000b
movl $0x1b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x938bb
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jne 0x938e9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x938e9
movl $0x0, 0x14(%rsp)
jmp 0x93930
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jb 0x9391e
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jne 0x93928
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x93928
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x93930
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x93b3e
cmpq $0x0, 0x10(%rsp)
jne 0x93b76
movq 0x120493(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xca517(%rip), %rsi     # 0x15e066
leaq 0xdc4e2(%rip), %rdx     # 0x170038
leaq 0xdc4ee(%rip), %rcx     # 0x17004b
leaq 0xdc4a7(%rip), %r8      # 0x17000b
movl $0x41, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x93b78
movq 0x18(%rsp), %rdi
callq 0x93bd0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x93bd0
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jne 0x93baa
movl $0x0, 0x24(%rsp)
jmp 0x93bc7
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jbe 0x93bbf
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x93bc7
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_range_overlap
bool gt_range_overlap(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->end && range_a->end >= range_b->start)
    return true;
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x93c71
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x93ca9
movq 0x120360(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xca3e4(%rip), %rsi     # 0x15e066
leaq 0xdc330(%rip), %rdx     # 0x16ffb9
leaq 0xdc3da(%rip), %rcx     # 0x17006a
leaq 0xdc374(%rip), %r8      # 0x17000b
movl $0x4d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x93cab
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x93cd6
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jb 0x93cd6
movb $0x1, 0x17(%rsp)
jmp 0x93cdb
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_range_within
bool gt_range_within(const GtRange *range, GtUword point)
{
  gt_assert(range->start <= range->end);

  if (range->start <= point && range->end >= point)
    return true;
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x93fa8
movq 0x120061(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xca0e5(%rip), %rsi     # 0x15e066
leaq 0xced5f(%rip), %rdx     # 0x162ce7
leaq 0xdc115(%rip), %rcx     # 0x1700a4
leaq 0xdc075(%rip), %r8      # 0x17000b
movl $0x8f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x93faa
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq (%rsp), %rax
ja 0x93fce
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
cmpq (%rsp), %rax
jb 0x93fce
movb $0x1, 0x17(%rsp)
jmp 0x93fd3
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x94014
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x9404c
movq 0x11ffbd(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xca041(%rip), %rsi     # 0x15e066
leaq 0xdbf8d(%rip), %rdx     # 0x16ffb9
leaq 0xdc081(%rip), %rcx     # 0x1700b4
leaq 0xdbfd1(%rip), %r8      # 0x17000b
movl $0x9a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9404e
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x9406f
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x9407c
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x940aa
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x940b8
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/range.c
// Function: gt_range_reorder
GtRange gt_range_reorder(GtRange range)
{
  GtRange ordered_range;
  if (range.start <= range.end)
    return range;
  ordered_range.start = range.end;
  ordered_range.end   = range.start;
  return ordered_range;
}

// Assembly:
movq %rdi, -0x20(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x20(%rsp), %rax
cmpq -0x18(%rsp), %rax
ja 0x9459c
movq -0x20(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x945c4
movq -0x18(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x20(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rdx
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x95659
movq 0x11e9b0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xc8a34(%rip), %rsi     # 0x15e066
leaq 0xe4e98(%rip), %rdx     # 0x17a4d1
leaq 0xdad99(%rip), %rcx     # 0x1703d9
leaq 0xda9c4(%rip), %r8      # 0x17000b
movl $0x14a, %r9d            # imm = 0x14A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x9565b
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x956d5
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
subq $0x1, %rsi
callq 0x75c80
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x75c80
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x93850
cmpl $0x1, %eax
jne 0x956c3
movb $0x0, 0x27(%rsp)
jmp 0x956da
jmp 0x956c5
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x95664
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)