LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7a1f6
movq %rdi, %rbx
callq 0x3dd98
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cvtsi2sd %eax, %xmm0
mulsd 0x777e1(%rip), %xmm0    # 0xf1988
leaq 0x1(%rbx), %rax
movq %rax, %xmm1
punpckldq 0x672c8(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x672d0(%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 0x705d0(%rip), %xmm2    # 0xea7b0
cvttsd2si %xmm2, %rax
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rcx, %rax
cmpq %rbx, %rax
ja 0x7a1fb
popq %rbx
retq
callq 0x1cb7a
callq 0x1cb43
// File: /workspace/github_c_makefile_star2_O1/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 0x7a212
jnp 0x7a246
callq 0x3dd98
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0x73765(%rip), %xmm0    # 0xed990
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
ucomisd 0x77754(%rip), %xmm0    # 0xf1990
jb 0x7a24b
ucomisd %xmm0, %xmm1
jb 0x7a24b
popq %rax
retq
callq 0x1cbb1
callq 0x1cbe8
// File: /workspace/github_c_makefile_star2_O1/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 0x3dd98
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cvtsi2sd %eax, %xmm0
divsd 0x73729(%rip), %xmm0    # 0xed990
movsd 0x67681(%rip), %xmm1    # 0xe18f0
ucomisd %xmm0, %xmm1
jb 0x7a277
popq %rax
retq
callq 0x1cc1f
// File: /workspace/github_c_makefile_star2_O1/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 0x7a188
cmpb $0x1a, %al
jae 0x7a28f
addb $0x61, %al
popq %rcx
retq
callq 0x1cc56
// File: /workspace/github_c_makefile_star2_O1/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 0x7a2a5
movq %rdi, %rcx
jmp 0x7a2bd
xorl %eax, %eax
movq %rdi, %rcx
addl $0x8, %eax
shrq $0x8, %rcx
cmpq $0xffff, %rdi           # imm = 0xFFFF
movq %rcx, %rdi
ja 0x7a2aa
leaq 0x7f47c(%rip), %rdx     # 0xf9740
movzbl (%rdx,%rcx), %ecx
subl %ecx, %eax
addl $0x8, %eax
cmpl $0x40, %eax
jae 0x7a2d4
popq %rcx
retq
callq 0x1cc8d
// File: /workspace/github_c_makefile_star2_O1/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 0x7a2ff
xorl %eax, %eax
cmpl $0x1f, %edi
jg 0x7a305
cmpl $0x7, %edi
jg 0x7a320
cmpl $0x2, %edi
je 0x7a352
movl $0x0, %ecx
cmpl $0x4, %edi
jne 0x7a36e
movl $0x2, %ecx
jmp 0x7a36c
movl $0x1, %eax
retq
cmpl $0x7f, %edi
jg 0x7a336
cmpl $0x20, %edi
je 0x7a359
movl $0x0, %ecx
cmpl $0x40, %edi
jne 0x7a36e
movl $0x6, %ecx
jmp 0x7a36c
cmpl $0x8, %edi
je 0x7a360
movl $0x0, %ecx
cmpl $0x10, %edi
jne 0x7a36e
movl $0x4, %ecx
jmp 0x7a36c
cmpl $0x80, %edi
je 0x7a367
movl $0x0, %ecx
cmpl $0x100, %edi            # imm = 0x100
jne 0x7a36e
movl $0x8, %ecx
jmp 0x7a36c
movl $0x1, %ecx
jmp 0x7a36c
movl $0x5, %ecx
jmp 0x7a36c
movl $0x3, %ecx
jmp 0x7a36c
movl $0x7, %ecx
movb $0x1, %al
testb %al, %al
je 0x7a383
imull %esi, %ecx
cmpl $0x40, %ecx
jae 0x7a39d
movl $0x1, %eax
shlq %cl, %rax
retq
movl %edi, %ecx
cmpl $0x1, %esi
jne 0x7a38e
movq %rcx, %rax
retq
movq %rcx, %rax
imulq %rcx, %rax
decl %esi
cmpl $0x1, %esi
ja 0x7a391
retq
pushq %rax
callq 0x1ccc6
// File: /workspace/github_c_makefile_star2_O1/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 0x702d5(%rip), %xmm1    # 0xea6a0
xorl %eax, %eax
xorl %ecx, %ecx
ucomisd %xmm1, %xmm3
seta %al
setae %cl
movsd 0x77597(%rip), %xmm3    # 0xf1978
ucomisd %xmm2, %xmm3
cmoval %eax, %ecx
testb %cl, %cl
je 0x7a3f4
addsd 0x70d6c(%rip), %xmm0    # 0xeb160
cvttsd2si %xmm0, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd %xmm4, %xmm0
andpd 0x73563(%rip), %xmm0    # 0xed970
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_O1/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 0x7a455
movl %edx, %ecx
xorl %edx, %edx
divl %ecx
movl %ecx, %eax
testl %edx, %edx
jne 0x7a442
movl %ecx, %eax
retq
pushq %rax
callq 0x1ccff
// File: /workspace/github_c_makefile_star2_O1/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 0x77613(%rip), %r14     # 0xf1ac6
movl $0x2, %edi
movl %ebx, %esi
callq 0x7a2d9
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
cmpl $0x40, %ebx
jne 0x7a4b3
movl $0x1, %ebx
leaq 0x775f6(%rip), %r14     # 0xf1ad7
movl $0x4, %edi
movl %ebx, %esi
callq 0x7a2d9
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
cmpl $0x20, %ebx
jne 0x7a4e1
movl $0x1, %ebx
leaq 0x775d9(%rip), %r14     # 0xf1ae8
movl $0x8, %edi
movl %ebx, %esi
callq 0x7a2d9
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
cmpl $0x10, %ebx
jne 0x7a50f
movl $0x1, %ebx
leaq 0x775bc(%rip), %r14     # 0xf1af9
movl $0x3, %edx
cmpl $0x1, %ebx
je 0x7a554
movl %ebx, %eax
leaq (%rdx,%rdx,2), %rdx
decl %eax
cmpl $0x1, %eax
ja 0x7a549
movq %r14, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0xb070
incl %ebx
cmpl $0x20, %ebx
jne 0x7a53d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7a753
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7a753
movq %rdi, %r14
cmpq %rbx, %rdi
je 0x7a723
leaq 0x77516(%rip), %r15     # 0xf1bdd
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 0x7749c(%rip), %rcx     # 0xf1ba0
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 0x7a72c
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 0x1cda8
// File: /workspace/github_c_makefile_star2_O1/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 0x7a771
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x7a87e
leaq 0x774b9(%rip), %rdi     # 0xf1c31
leaq 0x77489(%rip), %rsi     # 0xf1c08
callq 0x7a69b
testl %eax, %eax
je 0x7a7b2
leaq 0x689ea(%rip), %rsi     # 0xe3179
leaq 0x774df(%rip), %rdx     # 0xf1c75
leaq 0x774c1(%rip), %rcx     # 0xf1c5e
leaq 0x77424(%rip), %r8      # 0xf1bc8
movq %rbx, %rdi
movl $0x45, %r9d
jmp 0x7a870
leaq 0x77478(%rip), %rdi     # 0xf1c31
leaq 0x7744c(%rip), %rsi     # 0xf1c0c
callq 0x7a69b
cmpl $-0x1, %eax
je 0x7a7f1
leaq 0x689a8(%rip), %rsi     # 0xe3179
leaq 0x774d4(%rip), %rdx     # 0xf1cac
leaq 0x7747f(%rip), %rcx     # 0xf1c5e
leaq 0x773e2(%rip), %r8      # 0xf1bc8
movq %rbx, %rdi
movl $0x46, %r9d
jmp 0x7a870
leaq 0x77414(%rip), %rdi     # 0xf1c0c
leaq 0x77432(%rip), %rsi     # 0xf1c31
callq 0x7a69b
cmpl $0x1, %eax
jne 0x7a84b
leaq 0x773fc(%rip), %rdi     # 0xf1c0c
leaq 0x7741e(%rip), %rsi     # 0xf1c35
callq 0x7a69b
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jg 0x7a87c
leaq 0x6894e(%rip), %rsi     # 0xe3179
leaq 0x774dd(%rip), %rdx     # 0xf1d0f
leaq 0x77425(%rip), %rcx     # 0xf1c5e
leaq 0x77388(%rip), %r8      # 0xf1bc8
movq %rbx, %rdi
movl $0x49, %r9d
jmp 0x7a870
leaq 0x68927(%rip), %rsi     # 0xe3179
leaq 0x77485(%rip), %rdx     # 0xf1cde
leaq 0x773fe(%rip), %rcx     # 0xf1c5e
leaq 0x77361(%rip), %r8      # 0xf1bc8
movq %rbx, %rdi
movl $0x47, %r9d
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
retq
callq 0x1cddf
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x7b19b
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 0x7b191
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 0x7b191
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 0x7b16e
addq %rbx, %r14
movq %r12, %rbp
cmpq %r13, %r12
ja 0x7b155
movq 0x10(%rsp), %rsi
decq %rsi
jne 0x7b138
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 %rax
movq %rdi, 0xd7a24(%rip)     # 0x152bd8
movq %rsi, 0xd7a25(%rip)     # 0x152be0
movq $0x0, 0xd7a22(%rip) # 0x152be8
cmpq $0x0, (%rdi)
jne 0x7b21a
xorl %edi, %edi
callq 0x83728
movq %rax, 0xd7a16(%rip)     # 0x152bf0
callq 0x7b21f
callq 0xa5084
testb %al, %al
je 0x7b1ed
callq 0x7b270
leaq 0x45c(%rip), %rsi       # 0x7b650
movl $0xe, %edi
callq 0x836fe
leaq 0x4ae(%rip), %rsi       # 0x7b6b3
movl $0x1c, %edi
callq 0x836fe
movl $0x1, %edi
popq %rax
jmp 0xbc60
callq 0x1ce16
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
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, %edx
movl $0x200, %esi            # imm = 0x200
cmpl %esi, %edx
cmovael %esi, %ecx
incl %ecx
testw %dx, %dx
movzwl %cx, %ecx
movl $0x51, %edx
cmovel %edx, %ecx
cmpl $-0x1, %eax
cmovel %edx, %ecx
movl %ecx, 0xd7996(%rip)     # 0x152c00
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movl %edi, %ebp
callq 0xb060
cmpl $0xe, %ebp
jne 0x7b6ae
movq %rax, %rbx
movl (%rax), %ebp
cmpl $0x0, 0xd75ad(%rip)     # 0x152c18
je 0x7b67c
callq 0x7b21f
movl $0x0, 0xd759c(%rip)     # 0x152c18
callq 0xa5084
testb %al, %al
je 0x7b68a
callq 0x7b270
leaq -0x41(%rip), %rsi       # 0x7b650
movl $0xe, %edi
callq 0x836fe
movl $0x1, %edi
callq 0xbc60
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1ce4f
// File: /workspace/github_c_makefile_star2_O1/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 0xa5084
testb %al, %al
je 0x7b72f
movq 0xd7517(%rip), %rax     # 0x152bf8
cmpq 0xd74f8(%rip), %rax     # 0x152be0
je 0x7b700
movq 0xd74e7(%rip), %rax     # 0x152bd8
movq (%rax), %rax
movq %rax, 0xd74e5(%rip)     # 0x152be0
callq 0x7b270
leaq 0x7c1a2(%rip), %rsi     # 0xf78a9
movl $0x1, %edx
movl $0x1, %edi
callq 0x83752
movl $0xe, %edi
xorl %esi, %esi
callq 0x836fe
movl $0x1c, %edi
xorl %esi, %esi
popq %rax
jmp 0x836fe
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x7c18e
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 0x7c15c
addq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0x7c18e
leaq 0x8(%rdi), %rdx
movq (%rdi), %r8
leaq 0x1(%rax), %rsi
movq %rsi, 0x8(%rdi)
movq (%r8,%rax,8), %rax
cmpq %rcx, %rsi
jne 0x7c180
xorps %xmm0, %xmm0
movups %xmm0, (%rdx)
retq
cmpq 0x18(%rdi), %rsi
jne 0x7c18d
movq $0x0, (%rdx)
retq
pushq %rax
callq 0x1cf2f
// File: /workspace/github_c_makefile_star2_O1/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 0x7c1bb
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 0x7c1ba
addq 0x18(%rdi), %rax
retq
pushq %rax
callq 0x1cf66
// File: /workspace/github_c_makefile_star2_O1/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 0x7c3fe
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x7c4fe
testq %r12, %r12
je 0x7c4f9
testq %r15, %r15
je 0x7c4f9
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 0x7c437
addq 0x18(%r12), %rcx
xorl %ebp, %ebp
testq %rcx, %rcx
je 0x7c4e8
cmpq %r13, %rax
jle 0x7c47f
cmpq 0x10(%r12), %r13
jge 0x7c4e8
leaq (,%r13,8), %r14
movq (%r12), %rdi
addq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq *%r15
testl %eax, %eax
jne 0x7c4e6
incq %r13
addq $0x8, %r14
cmpq 0x10(%r12), %r13
jl 0x7c45a
jmp 0x7c4e8
cmpq 0x18(%r12), %r13
jge 0x7c4b1
leaq (,%r13,8), %r14
movq (%r12), %rdi
addq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq *%r15
testl %eax, %eax
jne 0x7c4e6
incq %r13
addq $0x8, %r14
cmpq 0x18(%r12), %r13
jl 0x7c48e
cmpq $0x0, 0x10(%r12)
jle 0x7c4e8
xorl %r14d, %r14d
xorl %r13d, %r13d
movq (%r12), %rdi
addq %r14, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq *%r15
testl %eax, %eax
jne 0x7c4e6
incq %r13
addq $0x8, %r14
cmpq 0x10(%r12), %r13
jl 0x7c4bf
xorl %ebp, %ebp
jmp 0x7c4e8
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d0ba
callq 0x1d081
// File: /workspace/github_c_makefile_star2_O1/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 0x7c52f
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x7c61e
testq %r12, %r12
je 0x7c619
testq %r15, %r15
je 0x7c619
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 0x7c568
addq 0x18(%r12), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x7c60a
cmpq %rdi, %r13
jle 0x7c5a7
leaq -0x8(,%r13,8), %rdi
incq %r13
decq %r13
cmpq 0x8(%r12), %r13
jle 0x7c608
leaq -0x8(%rdi), %rbp
addq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movq %rbp, %rdi
testl %eax, %eax
je 0x7c583
jmp 0x7c60a
leaq -0x8(,%r13,8), %rdi
incq %r13
decq %r13
testq %r13, %r13
jle 0x7c5d4
leaq -0x8(%rdi), %rbp
addq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movq %rbp, %rdi
testl %eax, %eax
je 0x7c5b2
jmp 0x7c60a
movq 0x18(%r12), %r13
leaq -0x8(,%r13,8), %rdi
incq %r13
decq %r13
cmpq 0x8(%r12), %r13
jle 0x7c608
leaq -0x8(%rdi), %rbp
addq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movq %rbp, %rdi
testl %eax, %eax
je 0x7c5e4
jmp 0x7c60a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d12c
callq 0x1d0f3
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x7de6d
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x7dec9
testq %rbx, %rbx
je 0x7dec4
movq (%rbx), %r12
movq (%r15), %r15
xorl %eax, %eax
cmpq %r15, %r12
je 0x7deb0
leaq 0x652f3(%rip), %rsi     # 0xe3179
leaq 0x74520(%rip), %rdx     # 0xf23ad
leaq 0x744ff(%rip), %rcx     # 0xf2393
leaq 0x741aa(%rip), %r8      # 0xf2045
movq %r14, %rdi
movl $0x10a, %r9d            # imm = 0x10A
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r15, %r12
jne 0x7deb8
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1d1d7
callq 0x1d19e
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x7def0
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x7df4c
testq %rbx, %rbx
je 0x7df47
movq (%rbx), %r12
movq (%r15), %r15
xorl %eax, %eax
cmpq %r15, %r12
je 0x7df33
leaq 0x65270(%rip), %rsi     # 0xe3179
leaq 0x744e7(%rip), %rdx     # 0xf23f7
leaq 0x744b6(%rip), %rcx     # 0xf23cd
leaq 0x74127(%rip), %r8      # 0xf2045
movq %r14, %rdi
movl $0x116, %r9d            # imm = 0x116
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r15, %r12
jne 0x7df3b
decq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1d249
callq 0x1d210
// File: /workspace/github_c_makefile_star2_O1/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 0x7df9f
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdi
ja 0x7df9f
movq %rdx, %r8
xorq %rdi, %r8
movq %rcx, %r9
xorq %rsi, %r9
xorl %eax, %eax
orq %r8, %r9
je 0x7df9e
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 0x1d282
// File: /workspace/github_c_makefile_star2_O1/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 0x7e016
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdi
ja 0x7e016
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 0x1d2b9
// File: /workspace/github_c_makefile_star2_O1/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 0x7e056
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7e056
callq 0x7e05b
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e05b
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 0x1d2f0
// File: /workspace/github_c_makefile_star2_O1/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 0x7e118
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
jb 0x7e118
incq %rcx
xorl %eax, %eax
cmpq %rbx, %rcx
jb 0x7e112
incq %rdx
cmpq %rbx, %rdx
jb 0x7e112
movq %rdi, %r15
movq %r14, %rsi
callq 0x7e06e
testb %al, %al
je 0x7e110
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movb $0x1, %al
cmpq %rdi, %rsi
jbe 0x7e100
cmpq %rdx, %rcx
jbe 0x7e112
subq %rsi, %rdx
incq %rdx
cmpq %rbx, %rdx
jb 0x7e110
jmp 0x7e112
cmpq %rdx, %rcx
jae 0x7e112
subq %rdi, %rcx
incq %rcx
cmpq %rbx, %rcx
jae 0x7e112
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d397
// File: /workspace/github_c_makefile_star2_O1/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 0x7e192
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
cmpq %rdx, %rax
ja 0x7e192
cmpq %rax, %r8
cmovbq %r8, %rax
cmpq %rdx, %rcx
cmovaq %rcx, %rdx
retq
pushq %rax
callq 0x1d440
// File: /workspace/github_c_makefile_star2_O1/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), %rcx
cmpq %rcx, %rax
ja 0x7e20a
leaq (%rax,%rsi), %r8
movq %rsi, %rdx
notq %rdx
xorl %r9d, %r9d
cmpq %rdx, %rax
setbe %r9b
movq %rsi, %rdi
negq %rdi
xorl %r10d, %r10d
cmpq %rdi, %rax
setae %r10b
testq %rsi, %rsi
cmovlel %r10d, %r9d
xorl %eax, %eax
testb %r9b, %r9b
cmovneq %r8, %rax
je 0x7e20f
leaq (%rcx,%rsi), %r8
xorl %r9d, %r9d
cmpq %rdx, %rcx
setbe %r9b
xorl %edx, %edx
cmpq %rdi, %rcx
setae %dl
testq %rsi, %rsi
cmovlel %edx, %r9d
xorl %edx, %edx
testb %r9b, %r9b
cmovneq %r8, %rdx
je 0x7e214
cmpq %rdx, %rax
ja 0x7e219
popq %rcx
retq
callq 0x1d50c
callq 0x1d479
callq 0x1d4a6
callq 0x1d4d3
// File: /workspace/github_c_makefile_star2_O1/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 0x7ea49
movq %rdi, %rbx
callq 0x6ecda
cmpq $0x2, %rax
setb %bpl
jae 0x7e9db
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6e9fa
movq %rax, %r15
movl $0x1, %r14d
movl $0x1, %esi
movq %rbx, %rdi
callq 0x6e9fa
movq %r15, %rdi
movq %rax, %rsi
callq 0x7df58
cmpl $0x1, %eax
je 0x7e9ce
leaq 0x1(%r14), %r15
movq %rbx, %rdi
callq 0x6ecda
cmpq %rax, %r15
setae %bpl
jae 0x7e9ce
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq %r14, %rdi
movq %rax, %rsi
callq 0x7df58
movq %r15, %r14
jmp 0x7ea06
callq 0x1d6d4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_do_not_overlap
bool gt_ranges_do_not_overlap(const GtArray *ranges)
{
  GtUword i;

  gt_assert(ranges && gt_array_size(ranges));

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7eafb
movq %rdi, %rbx
callq 0x6ecda
testq %rax, %rax
je 0x7eafb
movq %rbx, %rdi
callq 0x6ecda
cmpq $0x2, %rax
setb %bpl
jae 0x7ea8e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6e9fa
movq %rax, %r15
movl $0x1, %r14d
movl $0x1, %esi
movq %rbx, %rdi
callq 0x6e9fa
movq %r15, %rdi
movq %rax, %rsi
callq 0x7e06e
testb %al, %al
jne 0x7ea81
leaq 0x1(%r14), %r15
movq %rbx, %rdi
callq 0x6ecda
cmpq %rax, %r15
setae %bpl
jae 0x7ea81
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq %r14, %rdi
movq %rax, %rsi
callq 0x7e06e
movq %r15, %r14
jmp 0x7eab9
callq 0x1d70d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_are_equal
bool gt_ranges_are_equal(const GtArray *ranges_1, const GtArray *ranges_2)
{
  GtUword i;

  gt_assert(gt_ranges_are_sorted(ranges_1) && gt_ranges_are_sorted(ranges_2));

  if (gt_array_size(ranges_1) != gt_array_size(ranges_2))
    return false;

  for (i = 0; i < gt_array_size(ranges_1); i++) {
    if (gt_range_compare(gt_array_get(ranges_1, i), gt_array_get(ranges_2, i)))
      return false;
  }

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7e9ac
testb %al, %al
je 0x7ebb9
movq %rbx, %rdi
callq 0x7e9ac
testb %al, %al
je 0x7ebb9
movq %r14, %rdi
callq 0x6ecda
movq %rax, %r15
movq %rbx, %rdi
callq 0x6ecda
cmpq %rax, %r15
jne 0x7eba7
movq %r14, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x7ebab
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq %r12, %rdi
movq %rax, %rsi
callq 0x7df58
testl %eax, %eax
sete %bpl
jne 0x7ebae
incq %r15
movq %r14, %rdi
callq 0x6ecda
cmpq %rax, %r15
jb 0x7eb69
jmp 0x7ebae
xorl %ebp, %ebp
jmp 0x7ebae
movb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d746
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/range.c
// Function: generic_ranges_uniq
static GtArray* generic_ranges_uniq(GtArray *out_ranges,
                                    const GtArray *in_ranges, bool count)
{
  GtUword i, *ctr_ptr, ctr = 1;
  GtArray *count_array = NULL;
  GtRange cur  = { GT_UNDEF_UWORD, GT_UNDEF_UWORD },
        prev = { GT_UNDEF_UWORD, GT_UNDEF_UWORD };
  gt_assert(out_ranges && in_ranges);
  gt_assert(gt_ranges_are_sorted(in_ranges));
  if (count)
    count_array = gt_array_new(sizeof (GtUword));
  for (i = 0; i < gt_array_size(in_ranges); i++) {
    cur = *(GtRange*) gt_array_get(in_ranges, i);
    if (!i) {
      gt_array_add(out_ranges, cur);
      if (count)
        gt_array_add(count_array, ctr);
    }
    else {
      if (prev.start == cur.start && prev.end == cur.end) {
        if (count) {
          ctr_ptr = gt_array_get_last(count_array);
          (*ctr_ptr)++;
        }
      }
      else {
        gt_array_add(out_ranges, cur);
        if (count)
          gt_array_add(count_array, ctr);
      }
    }
    prev = cur;
  }
  return count_array;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq $0x1, 0x20(%rsp)
pcmpeqd %xmm0, %xmm0
movdqa %xmm0, 0x10(%rsp)
testq %rdi, %rdi
je 0x7ecd3
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x7e9ac
testb %al, %al
je 0x7ecd8
testb %bl, %bl
je 0x7ec15
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x8(%rsp)
jmp 0x7ec1e
movq $0x0, 0x8(%rsp)
movq %r14, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x7ecbf
movq $-0x1, %rbp
xorl %r13d, %r13d
movq $-0x1, %r12
movq %r14, %rdi
movq %r13, %rsi
callq 0x6e9fa
movdqu (%rax), %xmm0
movdqa %xmm0, 0x10(%rsp)
testq %r13, %r13
je 0x7ec7b
cmpq 0x10(%rsp), %rbp
jne 0x7ec7b
cmpq 0x18(%rsp), %r12
jne 0x7ec7b
testb %bl, %bl
je 0x7eca5
movq 0x8(%rsp), %rdi
callq 0x6ea1e
incq (%rax)
jmp 0x7eca5
movl $0x10, %edx
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x6ec0e
testb %bl, %bl
je 0x7eca5
movl $0x8, %edx
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6ec0e
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %r12
incq %r13
movq %r14, %rdi
callq 0x6ecda
cmpq %rax, %r13
jb 0x7ec40
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d7b8
callq 0x1d77f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/range.c
// Function: generic_ranges_uniq_in_place
static GtArray* generic_ranges_uniq_in_place(GtArray *ranges, bool count)
{
  GtArray *out_ranges, *count_array;
  gt_assert(ranges);
  out_ranges = gt_array_new(sizeof (GtRange));
  count_array = generic_ranges_uniq(out_ranges, ranges, count);
  gt_array_reset(ranges);
  gt_array_add_array(ranges, out_ranges); /* XXX: could be more efficient
                                               with something like
                                               gt_array_replace(ranges,
                                                             out_ranges) */
  gt_array_delete(out_ranges);
  return count_array;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x10, %edi
callq 0x6e93c
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x7ebbe
movq %rax, %rbx
movq %r14, %rdi
callq 0x6ed13
movq %r14, %rdi
movq %r15, %rsi
callq 0x6ec83
movq %r15, %rdi
callq 0x6f134
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_are_consecutive
bool gt_ranges_are_consecutive(const GtArray *ranges)
{
  GtUword i;
  for (i = 0; i < gt_array_size(ranges); i++) {
    gt_assert(((GtRange*) gt_array_get(ranges, i))->start <=
              ((GtRange*) gt_array_get(ranges, i))->end);
    if (i) {
      /* check if ranges are consecutive */
      if (((GtRange*) gt_array_get(ranges, i-1))->end >=
          ((GtRange*) gt_array_get(ranges, i))->start) {
        return false;
      }
    }
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6ecda
testq %rax, %rax
sete %bpl
je 0x7ed9b
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
cmpq 0x8(%rax), %r15
ja 0x7edac
testq %r14, %r14
je 0x7ed87
leaq -0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x6e9fa
movq 0x8(%rax), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
cmpq (%rax), %r15
jae 0x7ed9b
incq %r14
movq %rbx, %rdi
callq 0x6ecda
cmpq %rax, %r14
setae %bpl
jb 0x7ed43
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d7f1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_total_length
GtUword gt_ranges_total_length(const GtArray *ranges)
{
  GtUword i, totallen = 0;
  GtRange *range;
  gt_assert(ranges);
  for (i = 0; i < gt_array_size(ranges); i++) {
    range = gt_array_get(ranges, i);
    totallen += range->end - range->start + 1;
  }
  return totallen;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x7ee01
movq %rdi, %rbx
callq 0x6ecda
testq %rax, %rax
je 0x7edf5
xorl %r15d, %r15d
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6e9fa
addq 0x8(%rax), %r14
subq (%rax), %r14
incq %r14
incq %r15
movq %rbx, %rdi
callq 0x6ecda
cmpq %rax, %r15
jb 0x7edce
jmp 0x7edf8
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d82a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_spanned_length
GtUword gt_ranges_spanned_length(const GtArray *ranges)
{
  GtRange spanned_range;
  gt_assert(ranges);
  spanned_range.start = ((GtRange*) gt_array_get_first(ranges))->start;
  spanned_range.end   = ((GtRange*) gt_array_get_last(ranges))->end;
  return gt_range_length(&spanned_range);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x7ee45
movq %rdi, %rbx
callq 0x6ea17
movq (%rax), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x6ea1e
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x7e05b
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x1d863
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_copy_to_opposite_strand
void gt_ranges_copy_to_opposite_strand(GtArray *outranges,
                                       const GtArray *inranges,
                                       GtUword gen_total_length,
                                       GtUword gen_offset)
{
  GtRange range;
  GtUword i;

  /* outranges are empty */
  gt_assert(!gt_array_size(outranges));
  /* inranges are not empty */
  gt_assert(gt_array_size(inranges));

  for (i = gt_array_size(inranges); i > 0; i--) {
    /* genomic offset is defined */
    gt_assert(gen_offset != GT_UNDEF_UWORD);
    range.start  = gen_total_length - 1
                  - (((GtRange*) gt_array_get(inranges, i-1))->end -
                     gen_offset)
                  + gen_offset;
    range.end = gen_total_length - 1
                  - (((GtRange*) gt_array_get(inranges, i-1))->start -
                     gen_offset)
                  + gen_offset;
    gt_array_add(outranges, range);
  }

  /* outranges has the same number of elements as inranges */
  gt_assert(gt_array_size(inranges) == gt_array_size(outranges));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6ecda
testq %rax, %rax
jne 0x7ef0f
movq %r14, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x7ef14
movq %r14, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x7eee9
cmpq $-0x1, %r12
je 0x7ef1e
movq %rax, %r15
leaq -0x1(%r13,%r12,2), %r13
decq %r15
movq %rsp, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq %r13, %rcx
subq 0x8(%rax), %rcx
movq %rcx, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq %r13, %rcx
subq (%rax), %rcx
movq %rcx, 0x8(%rsp)
movl $0x10, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6ec0e
addq $-0x1, %r15
jb 0x7eea7
movq %r14, %rdi
callq 0x6ecda
movq %rax, %r14
movq %rbx, %rdi
callq 0x6ecda
cmpq %rax, %r14
jne 0x7ef19
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1d89c
callq 0x1d947
callq 0x1d90e
callq 0x1d8d5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_borders_are_in_region
bool gt_ranges_borders_are_in_region(GtArray *ranges, const GtRange *region)
{
  gt_assert(ranges && region);

  /* check region start */
  if (((GtRange*) gt_array_get_first(ranges))->start < region->start)
    return false;

  /* check region end */
  if (((GtRange*) gt_array_get_last(ranges))->end > region->end)
    return false;

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x7ef63
movq %rsi, %rbx
testq %rsi, %rsi
je 0x7ef63
movq %rdi, %r14
callq 0x6ea17
movq (%rax), %rax
cmpq (%rbx), %rax
jae 0x7ef48
xorl %eax, %eax
jmp 0x7ef5b
movq %r14, %rdi
callq 0x6ea1e
movq 0x8(%rax), %rax
cmpq 0x8(%rbx), %rax
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1d980