LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
pushq $0x1
popq %rbx
pushq $0x2
popq %rbp
leaq 0x8182d(%rip), %r14     # 0xdaa66
cmpl $0x40, %ebx
je 0x5925a
movl %ebp, %edi
movl %ebx, %esi
callq 0x59049
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
jmp 0x59239
pushq $0x1
popq %rbx
pushq $0x4
popq %rbp
leaq 0x81810(%rip), %r14     # 0xdaa77
cmpl $0x20, %ebx
je 0x59288
movl %ebp, %edi
movl %ebx, %esi
callq 0x59049
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
jmp 0x59267
pushq $0x1
popq %rbx
pushq $0x8
popq %rbp
leaq 0x817f3(%rip), %r14     # 0xdaa88
cmpl $0x10, %ebx
je 0x592b6
movl %ebp, %edi
movl %ebx, %esi
callq 0x59049
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
jmp 0x59295
pushq $0x1
popq %rbx
pushq $0x3
popq %rbp
leaq 0x817d6(%rip), %r14     # 0xdaa99
cmpl $0x20, %ebx
je 0x592e4
movl %ebp, %edi
movl %ebx, %esi
callq 0x59049
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb070
incl %ebx
jmp 0x592c3
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x59b1c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x59b1c
movq %rdi, %r14
cmpq %rbx, %rdi
je 0x59afc
movq %r14, %rdi
callq 0x59a50
movzbl %al, %r15d
movq %rbx, %rdi
callq 0x59a50
movl %eax, %ecx
leal 0x2(%r15), %eax
testb %cl, %cl
cmovel %r15d, %eax
leaq 0x8138d(%rip), %rcx     # 0xdae70
movslq (%rcx,%rax,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb880
xorl %eax, %eax
jmp 0x59b03
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x25
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xb2a0
movq 0xd4495(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x70539(%rip), %rsi     # 0xca066
leaq 0x8137e(%rip), %rdx     # 0xdaeb2
leaq 0x81384(%rip), %rcx     # 0xdaebf
leaq 0x81356(%rip), %r8      # 0xdae98
pushq $0x22
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x59b6b
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x59cc2
leaq 0x8138f(%rip), %rdi     # 0xdaf01
callq 0x59a50
testb %al, %al
je 0x59b9b
leaq 0x725d7(%rip), %rsi     # 0xcc159
leaq 0x813bc(%rip), %rdx     # 0xdaf45
leaq 0x8139e(%rip), %rcx     # 0xdaf2e
leaq 0x81301(%rip), %r8      # 0xdae98
pushq $0x42
jmp 0x59c00
leaq 0x8133a(%rip), %rdi     # 0xdaedc
callq 0x59a50
testb %al, %al
je 0x59be2
leaq 0x8134f(%rip), %rdi     # 0xdaf01
leaq 0x8131f(%rip), %rsi     # 0xdaed8
callq 0x59aa2
testl %eax, %eax
je 0x59c11
leaq 0x72590(%rip), %rsi     # 0xcc159
leaq 0x813ba(%rip), %rdx     # 0xdaf8a
leaq 0x81357(%rip), %rcx     # 0xdaf2e
leaq 0x812ba(%rip), %r8      # 0xdae98
pushq $0x45
jmp 0x59c00
leaq 0x72570(%rip), %rsi     # 0xcc159
leaq 0x81376(%rip), %rdx     # 0xdaf66
leaq 0x81337(%rip), %rcx     # 0xdaf2e
leaq 0x8129a(%rip), %r8      # 0xdae98
pushq $0x43
popq %r9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
popq %rbx
retq
leaq 0x812e9(%rip), %rdi     # 0xdaf01
leaq 0x812bd(%rip), %rsi     # 0xdaedc
callq 0x59aa2
cmpl $-0x1, %eax
je 0x59c49
leaq 0x72529(%rip), %rsi     # 0xcc159
leaq 0x8138a(%rip), %rdx     # 0xdafc1
leaq 0x812f0(%rip), %rcx     # 0xdaf2e
leaq 0x81253(%rip), %r8      # 0xdae98
pushq $0x46
jmp 0x59c00
leaq 0x8128c(%rip), %rdi     # 0xdaedc
leaq 0x812aa(%rip), %rsi     # 0xdaf01
callq 0x59aa2
cmpl $0x1, %eax
jne 0x59c9f
leaq 0x81274(%rip), %rdi     # 0xdaedc
leaq 0x81296(%rip), %rsi     # 0xdaf05
callq 0x59aa2
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jg 0x59c0f
leaq 0x724d6(%rip), %rsi     # 0xcc159
leaq 0x8139a(%rip), %rdx     # 0xdb024
leaq 0x8129d(%rip), %rcx     # 0xdaf2e
leaq 0x81200(%rip), %r8      # 0xdae98
pushq $0x49
jmp 0x59c00
leaq 0x724b3(%rip), %rsi     # 0xcc159
leaq 0x81346(%rip), %rdx     # 0xdaff3
leaq 0x8127a(%rip), %rcx     # 0xdaf2e
leaq 0x811dd(%rip), %r8      # 0xdae98
pushq $0x47
jmp 0x59c00
movq 0xd42ef(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x70393(%rip), %rsi     # 0xca066
leaq 0x7097f(%rip), %rdx     # 0xca659
leaq 0x8124d(%rip), %rcx     # 0xdaf2e
leaq 0x811b0(%rip), %r8      # 0xdae98
pushq $0x40
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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)
movq %rdx, %r15
movq %rdi, %r14
movq %rdx, %rbx
negq %rbx
movq %rdi, %r13
decq %rsi
je 0x5a54e
movq %rsi, 0x10(%rsp)
leaq (%r15,%r13), %rbp
movq %rbp, 0x8(%rsp)
cmpq %r14, %rbp
jbe 0x5a542
leaq (%rbx,%rbp), %r12
movq %r12, %rdi
movq %rbp, %rsi
movq 0x18(%rsp), %rdx
callq *0x20(%rsp)
testl %eax, %eax
jle 0x5a542
xorl %eax, %eax
movb (%r13,%rax), %cl
movb (%rbp,%rax), %dl
movb %dl, (%r13,%rax)
movb %cl, (%rbp,%rax)
incq %rax
cmpl %eax, %r15d
jne 0x5a520
addq %rbx, %r13
movq %r12, %rbp
jmp 0x5a502
movq 0x8(%rsp), %r13
movq 0x10(%rsp), %rsi
jmp 0x5a4ef
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0xd566f(%rip)     # 0x12fbd8
movq %rdi, 0xd5658(%rip)     # 0x12fbc8
movq %rsi, 0xd5659(%rip)     # 0x12fbd0
cmpq $0x0, (%rdi)
jne 0x5a5c5
xorl %edi, %edi
callq 0x62606
movq %rax, 0xd5655(%rip)     # 0x12fbe0
callq 0x5a5fd
callq 0x84988
testb %al, %al
je 0x5a59e
callq 0x5a64b
leaq 0x42d(%rip), %rsi       # 0x5a9d2
pushq $0xe
popq %rdi
callq 0x62597
leaq 0x4b0(%rip), %rsi       # 0x5aa64
pushq $0x1c
popq %rdi
callq 0x62597
pushq $0x1
popq %rdi
popq %rax
jmp 0xbc50
movq 0xd39ec(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6fa90(%rip), %rsi     # 0xca066
leaq 0x80a91(%rip), %rdx     # 0xdb06e
leaq 0x80aa4(%rip), %rcx     # 0xdb088
leaq 0x80ab2(%rip), %r8      # 0xdb09d
movl $0xd0, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5aa2c
movq %rax, %rbx
movl (%rax), %ebp
cmpl $0x0, 0xd521b(%rip)     # 0x12fc08
je 0x5a9fe
callq 0x5a5fd
movl $0x0, 0xd520a(%rip)     # 0x12fc08
callq 0x84988
testb %al, %al
je 0x5aa0c
callq 0x5a64b
leaq -0x41(%rip), %rsi       # 0x5a9d2
pushq $0xe
popq %rdi
callq 0x62597
pushq $0x1
popq %rdi
callq 0xbc50
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xd3585(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6f629(%rip), %rsi     # 0xca066
leaq 0x808cb(%rip), %rdx     # 0xdb30f
leaq 0x808d9(%rip), %rcx     # 0xdb324
leaq 0x8064b(%rip), %r8      # 0xdb09d
movl $0xb3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbc50
callq 0x84988
testb %al, %al
je 0x5ab0b
movq 0xd5123(%rip), %rax     # 0x12fbe8
cmpq 0xd5104(%rip), %rax     # 0x12fbd0
je 0x5aae4
movq 0xd50f3(%rip), %rax     # 0x12fbc8
movq (%rax), %rax
movq %rax, 0xd50f1(%rip)     # 0x12fbd0
callq 0x5a64b
leaq 0x860de(%rip), %rsi     # 0xe0bc9
pushq $0x1
popq %rdi
pushq $0x1
popq %rdx
callq 0x62675
pushq $0xe
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x1c
popq %rdi
xorl %esi, %esi
popq %rax
jmp 0x62597
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/qsort_r.c
// Function: swapfunc
static inline void
swapfunc(char *a, char *b, int n, int swaptype)
{
  if (swaptype <= 1)
    swapcode(GtWord, a, b, n);
  else
    swapcode(char, a, b, n);
}

// Assembly:
movslq %edx, %rax
cmpl $0x2, %ecx
jge 0x5afa8
shrq $0x3, %rax
incq %rax
xorl %ecx, %ecx
movq (%rdi,%rcx), %rdx
movq (%rsi,%rcx), %r8
movq %r8, (%rdi,%rcx)
movq %rdx, (%rsi,%rcx)
addq $0x8, %rcx
decq %rax
cmpq $0x1, %rax
ja 0x5af89
jmp 0x5afc7
incq %rax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
movb (%rsi,%rcx), %r8b
movb %r8b, (%rdi,%rcx)
movb %dl, (%rsi,%rcx)
decq %rax
incq %rcx
cmpq $0x1, %rax
jg 0x5afad
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
testq %rdi, %rdi
je 0x5b1d9
movq %rdi, %rbx
callq 0x5b20f
testq %rax, %rax
je 0x5b1d9
leaq 0x8(%rbx), %rcx
movq (%rbx), %rax
movq 0x8(%rbx), %rsi
leaq 0x1(%rsi), %rdx
movq %rdx, 0x8(%rbx)
movq (%rax,%rsi,8), %rax
cmpq 0x10(%rbx), %rdx
jne 0x5b1cd
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
jmp 0x5b1d7
cmpq 0x18(%rbx), %rdx
jne 0x5b1d7
andq $0x0, (%rcx)
popq %rbx
retq
movq 0xd2dd8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6ee7c(%rip), %rsi     # 0xca066
leaq 0x80187(%rip), %rdx     # 0xdb378
leaq 0x80196(%rip), %rcx     # 0xdb38e
leaq 0x8015b(%rip), %r8      # 0xdb35a
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5b236
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 0x5b235
addq 0x18(%rdi), %rax
retq
pushq %rax
movq 0xd2d7a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6ee1e(%rip), %rsi     # 0xca066
leaq 0x82d11(%rip), %rdx     # 0xddf60
leaq 0x801b9(%rip), %rcx     # 0xdb40f
leaq 0x800fd(%rip), %r8      # 0xdb35a
movl $0xe7, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5b4c1
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x5b5c1
testq %r12, %r12
je 0x5b593
testq %r15, %r15
je 0x5b593
movq %r12, %rdi
callq 0x5b20f
xorl %r13d, %r13d
testq %rax, %rax
je 0x5b581
movq 0x8(%r12), %rbp
cmpq 0x10(%r12), %rbp
jge 0x5b523
leaq (,%rbp,8), %rdi
decq %rbp
incq %rbp
cmpq 0x10(%r12), %rbp
jge 0x5b581
leaq 0x8(%rdi), %r14
addq (%r12), %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq *%r15
movq %r14, %rdi
testl %eax, %eax
je 0x5b4fe
jmp 0x5b57e
leaq (,%rbp,8), %rdi
decq %rbp
incq %rbp
cmpq 0x18(%r12), %rbp
jge 0x5b553
leaq 0x8(%rdi), %r14
addq (%r12), %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq *%r15
movq %r14, %rdi
testl %eax, %eax
je 0x5b52e
jmp 0x5b57e
pushq $-0x1
popq %rbp
xorl %r13d, %r13d
xorl %edi, %edi
incq %rbp
cmpq 0x10(%r12), %rbp
jge 0x5b581
leaq 0x8(%rdi), %r14
addq (%r12), %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq *%r15
movq %r14, %rdi
testl %eax, %eax
je 0x5b55b
movl %eax, %r13d
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd2a1e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6eac2(%rip), %rsi     # 0xca066
leaq 0x7fe33(%rip), %rdx     # 0xdb3de
leaq 0x7fe1b(%rip), %rcx     # 0xdb3cd
leaq 0x7fda1(%rip), %r8      # 0xdb35a
movl $0xb5, %r9d
jmp 0x5b5ed
movq 0xd29f0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6ea94(%rip), %rsi     # 0xca066
leaq 0x6f080(%rip), %rdx     # 0xca659
leaq 0x7fded(%rip), %rcx     # 0xdb3cd
leaq 0x7fd73(%rip), %r8      # 0xdb35a
movl $0xb4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5b625
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x5b729
testq %r12, %r12
je 0x5b6fb
testq %r15, %r15
je 0x5b6fb
movq %r12, %rdi
callq 0x5b20f
xorl %ecx, %ecx
testq %rax, %rax
je 0x5b6ea
movq 0x10(%r12), %r13
cmpq %r13, 0x8(%r12)
jge 0x5b685
leaq -0x8(,%r13,8), %rdi
incq %r13
decq %r13
cmpq 0x8(%r12), %r13
jle 0x5b6e8
leaq -0x8(%rdi), %rbp
addq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movq %rbp, %rdi
testl %eax, %eax
je 0x5b661
jmp 0x5b6e4
leaq -0x8(,%r13,8), %rdi
incq %r13
decq %r13
testq %r13, %r13
jle 0x5b6b2
leaq -0x8(%rdi), %rbp
addq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movq %rbp, %rdi
testl %eax, %eax
je 0x5b690
jmp 0x5b6e4
movq 0x18(%r12), %r13
leaq -0x8(,%r13,8), %rdi
incq %r13
decq %r13
cmpq 0x8(%r12), %r13
jle 0x5b6e8
leaq -0x8(%rdi), %rbp
addq (%r12), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *%r15
movq %rbp, %rdi
testl %eax, %eax
je 0x5b6c2
movl %eax, %ecx
jmp 0x5b6ea
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd28b6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6e95a(%rip), %rsi     # 0xca066
leaq 0x7fccb(%rip), %rdx     # 0xdb3de
leaq 0x7fcdc(%rip), %rcx     # 0xdb3f6
leaq 0x7fc39(%rip), %r8      # 0xdb35a
movl $0xd0, %r9d
jmp 0x5b755
movq 0xd2888(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6e92c(%rip), %rsi     # 0xca066
leaq 0x6ef18(%rip), %rdx     # 0xca659
leaq 0x7fcae(%rip), %rcx     # 0xdb3f6
leaq 0x7fc0b(%rip), %r8      # 0xdb35a
movl $0xcf, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x5b7a4
leaq 0x7fbdd(%rip), %r14     # 0xdb35a
movq %rbx, %rdi
callq 0x5b20f
testq %rax, %rax
je 0x5b7a4
movq %rbx, %rdi
callq 0x5b195
movq %rax, %rdi
movq %r14, %rsi
movl $0xf2, %edx
callq 0xd249
jmp 0x5b77d
movq (%rbx), %rdi
leaq 0x7fbac(%rip), %r14     # 0xdb35a
movq %r14, %rsi
movl $0xf4, %edx
callq 0xd249
movq %rbx, %rdi
movq %r14, %rsi
movl $0xf5, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/queue.c
// Function: check_queue
static int check_queue(void **elem, void *info, GtError *err)
{
  long *check_counter = info;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(check_counter);
  gt_ensure(*check_counter == *(long*) elem);
  if (!had_err)
    (*check_counter)++;
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x5cd3e
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x5cdb8
testq %r14, %r14
je 0x5cd8a
movq (%r14), %rax
cmpq (%r15), %rax
jne 0x5cd55
incq %rax
movq %rax, (%r14)
xorl %eax, %eax
jmp 0x5cd84
leaq 0x6f3fd(%rip), %rsi     # 0xcc159
leaq 0x7e95f(%rip), %rdx     # 0xdb6c2
leaq 0x7e93e(%rip), %rcx     # 0xdb6a8
leaq 0x7e5e9(%rip), %r8      # 0xdb35a
movq %rbx, %rdi
movl $0x10a, %r9d            # imm = 0x10A
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xd1227(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6d2cb(%rip), %rsi     # 0xca066
leaq 0x7e912(%rip), %rdx     # 0xdb6b4
leaq 0x7e8ff(%rip), %rcx     # 0xdb6a8
leaq 0x7e5aa(%rip), %r8      # 0xdb35a
movl $0x109, %r9d            # imm = 0x109
jmp 0x5cde4
movq 0xd11f9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6d29d(%rip), %rsi     # 0xca066
leaq 0x6d889(%rip), %rdx     # 0xca659
leaq 0x7e8d1(%rip), %rcx     # 0xdb6a8
leaq 0x7e57c(%rip), %r8      # 0xdb35a
movl $0x108, %r9d            # imm = 0x108
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/queue.c
// Function: check_queue_reverse
static int check_queue_reverse(void **elem, void *info, GtError *err)
{
  long *check_counter_reverse = info;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(check_counter_reverse);
  gt_ensure(*check_counter_reverse == *(long*) elem);
  if (!had_err)
    (*check_counter_reverse)--;
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x5ce0f
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x5ce89
testq %r14, %r14
je 0x5ce5b
movq (%r14), %rax
cmpq (%r15), %rax
jne 0x5ce26
decq %rax
movq %rax, (%r14)
xorl %eax, %eax
jmp 0x5ce55
leaq 0x6f32c(%rip), %rsi     # 0xcc159
leaq 0x7e8d8(%rip), %rdx     # 0xdb70c
leaq 0x7e8a7(%rip), %rcx     # 0xdb6e2
leaq 0x7e518(%rip), %r8      # 0xdb35a
movq %rbx, %rdi
movl $0x116, %r9d            # imm = 0x116
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xd1156(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6d1fa(%rip), %rsi     # 0xca066
leaq 0x7e883(%rip), %rdx     # 0xdb6f6
leaq 0x7e868(%rip), %rcx     # 0xdb6e2
leaq 0x7e4d9(%rip), %r8      # 0xdb35a
movl $0x115, %r9d            # imm = 0x115
jmp 0x5ceb5
movq 0xd1128(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6d1cc(%rip), %rsi     # 0xca066
leaq 0x6d7b8(%rip), %rdx     # 0xca659
leaq 0x7e83a(%rip), %rcx     # 0xdb6e2
leaq 0x7e4ab(%rip), %r8      # 0xdb35a
movl $0x114, %r9d            # imm = 0x114
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5cf0f
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdi
ja 0x5cf0f
movq %rdx, %r8
xorq %rdi, %r8
movq %rcx, %r9
xorq %rsi, %r9
xorl %eax, %eax
orq %r8, %r9
je 0x5cf0e
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
movq 0xd10a1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6d145(%rip), %rsi     # 0xca066
leaq 0x7e80c(%rip), %rdx     # 0xdb734
leaq 0x7e846(%rip), %rcx     # 0xdb775
leaq 0x7e850(%rip), %r8      # 0xdb786
pushq $0x1b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5cfb7
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdi
ja 0x5cfb7
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
movq 0xd0ff9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6d09d(%rip), %rsi     # 0xca066
leaq 0x7e764(%rip), %rdx     # 0xdb734
leaq 0x7e7c0(%rip), %rcx     # 0xdb797
leaq 0x7e7a8(%rip), %r8      # 0xdb786
pushq $0x2c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5d028
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5d028
callq 0x5d05e
movq %rax, %r14
movq %rbx, %rdi
callq 0x5d05e
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
movq 0xd0f89(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6d02d(%rip), %rsi     # 0xca066
leaq 0x7e773(%rip), %rdx     # 0xdb7b3
leaq 0x7e77f(%rip), %rcx     # 0xdb7c6
leaq 0x7e738(%rip), %r8      # 0xdb786
pushq $0x41
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5d17f
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
jb 0x5d17f
incq %rcx
xorl %eax, %eax
cmpq %rbx, %rcx
jb 0x5d179
incq %rdx
cmpq %rbx, %rdx
jb 0x5d179
movq %rdi, %r15
movq %r14, %rsi
callq 0x5d0a4
testb %al, %al
je 0x5d177
movq (%r15), %rsi
movq 0x8(%r15), %rcx
movq (%r14), %rdi
movq 0x8(%r14), %rdx
movb $0x1, %al
cmpq %rdi, %rsi
jbe 0x5d167
cmpq %rdx, %rcx
jbe 0x5d179
subq %rsi, %rdx
incq %rdx
cmpq %rbx, %rdx
jb 0x5d177
jmp 0x5d179
cmpq %rdx, %rcx
jae 0x5d179
subq %rdi, %rcx
incq %rcx
cmpq %rbx, %rcx
jae 0x5d179
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0xd0e32(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6ced6(%rip), %rsi     # 0xca066
leaq 0x7e59d(%rip), %rdx     # 0xdb734
leaq 0x7e658(%rip), %rcx     # 0xdb7f6
leaq 0x7e5e1(%rip), %r8      # 0xdb786
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5d290
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
cmpq %rdx, %rax
ja 0x5d290
cmpq %rax, %r8
cmovbq %r8, %rax
cmpq %rdx, %rcx
cmovaq %rcx, %rdx
retq
pushq %rax
movq 0xd0d20(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6cdc4(%rip), %rsi     # 0xca066
leaq 0x7e48b(%rip), %rdx     # 0xdb734
leaq 0x7e57f(%rip), %rcx     # 0xdb82f
leaq 0x7e4cf(%rip), %r8      # 0xdb786
movl $0x9a, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/range.c
// Function: gt_range_offset
GtRange gt_range_offset(const GtRange *range, GtWord offset)
{
  GtRange transformed_range = { 0, 0 };
  gt_assert(range->start <= range->end);
  gt_safe_add(transformed_range.start, range->start, offset);
  gt_safe_add(transformed_range.end, range->end, offset);
  gt_assert(transformed_range.start <= transformed_range.end);
  return transformed_range;
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
cmpq %rdx, %rax
ja 0x5d31f
movq %rsi, %rcx
testq %rsi, %rsi
jle 0x5d30a
notq %rcx
cmpq %rcx, %rax
ja 0x5d34d
cmpq %rcx, %rdx
jbe 0x5d312
movq 0xd0cc6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7be3a(%rip), %rsi     # 0xd9136
leaq 0x7e483(%rip), %rdx     # 0xdb786
movl $0xa7, %ecx
jmp 0x5d36a
negq %rcx
cmpq %rcx, %rax
jb 0x5d34d
addq %rsi, %rdx
addq %rsi, %rax
cmpq %rdx, %rax
ja 0x5d379
popq %rcx
retq
movq 0xd0c92(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6cd36(%rip), %rsi     # 0xca066
leaq 0x71895(%rip), %rdx     # 0xcebcc
leaq 0x7e4ff(%rip), %rcx     # 0xdb83d
leaq 0x7e441(%rip), %r8      # 0xdb786
movl $0xa5, %r9d
jmp 0x5d3a5
movq 0xd0c64(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7bdd8(%rip), %rsi     # 0xd9136
leaq 0x7e421(%rip), %rdx     # 0xdb786
movl $0xa6, %ecx
xorl %eax, %eax
callq 0xb8c0
pushq $0x1
popq %rdi
callq 0xb7b0
movq 0xd0c38(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6ccdc(%rip), %rsi     # 0xca066
leaq 0x7e4bc(%rip), %rdx     # 0xdb84d
leaq 0x7e4a5(%rip), %rcx     # 0xdb83d
leaq 0x7e3e7(%rip), %r8      # 0xdb786
movl $0xa8, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5dc8e
movq %rdi, %rbx
pushq $0x1
popq %rcx
movq %rcx, %r14
movq %rbx, %rdi
callq 0x4b988
movq %rax, %r15
cmpq %rax, %r14
jae 0x5dc7c
leaq -0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x4b48e
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b48e
movq %r12, %rdi
movq %rax, %rsi
callq 0x5cec8
leaq 0x1(%r14), %rcx
cmpl $0x1, %eax
jne 0x5dc3b
cmpq %r15, %r14
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xd0323(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6c3c7(%rip), %rsi     # 0xca066
leaq 0x876b4(%rip), %rdx     # 0xe535a
leaq 0x7de82(%rip), %rcx     # 0xdbb2f
leaq 0x7dad2(%rip), %r8      # 0xdb786
movl $0x14a, %r9d            # imm = 0x14A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5dd35
movq %rdi, %rbx
callq 0x4b988
testq %rax, %rax
je 0x5dd35
pushq $0x1
popq %rcx
movq %rcx, %r14
movq %rbx, %rdi
callq 0x4b988
movq %rax, %r15
cmpq %rax, %r14
jae 0x5dd23
leaq -0x1(%r14), %rsi
movq %rbx, %rdi
callq 0x4b48e
movq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b48e
movq %r12, %rdi
movq %rax, %rsi
callq 0x5d0a4
leaq 0x1(%r14), %rcx
testb %al, %al
je 0x5dce3
cmpq %r15, %r14
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xd027c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6c320(%rip), %rsi     # 0xca066
leaq 0x7ddf7(%rip), %rdx     # 0xdbb44
leaq 0x7de10(%rip), %rcx     # 0xdbb64
leaq 0x7da2b(%rip), %r8      # 0xdb786
movl $0x159, %r9d            # imm = 0x159
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5dc28
testb %al, %al
je 0x5de10
movq %rbx, %rdi
callq 0x5dc28
testb %al, %al
je 0x5de10
movq %r14, %rdi
callq 0x4b988
movq %rax, %r15
movq %rbx, %rdi
callq 0x4b988
cmpq %rax, %r15
jne 0x5de03
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x4b988
cmpq %rax, %r15
setae %bpl
jae 0x5de05
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b48e
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b48e
movq %r12, %rdi
movq %rax, %rsi
callq 0x5cec8
incq %r15
testl %eax, %eax
je 0x5ddc5
jmp 0x5de05
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xd01a1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6c245(%rip), %rsi     # 0xca066
leaq 0x7dd55(%rip), %rdx     # 0xdbb7d
leaq 0x7dd8f(%rip), %rcx     # 0xdbbbe
leaq 0x7d950(%rip), %r8      # 0xdb786
movl $0x16b, %r9d            # imm = 0x16B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5df41
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x5dc28
testb %al, %al
je 0x5df6f
testb %bl, %bl
je 0x5de9d
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x8(%rsp)
jmp 0x5dea6
movq $0x0, 0x8(%rsp)
pushq $-0x1
popq %r12
xorl %r13d, %r13d
movq %r12, %rbp
movq %r14, %rdi
callq 0x4b988
cmpq %rax, %r13
jae 0x5df2d
movq %r14, %rdi
movq %r13, %rsi
callq 0x4b48e
movdqu (%rax), %xmm0
movdqa %xmm0, 0x10(%rsp)
testq %r13, %r13
je 0x5def8
cmpq 0x10(%rsp), %rbp
jne 0x5def8
cmpq 0x18(%rsp), %r12
jne 0x5def8
testb %bl, %bl
je 0x5df1e
movq 0x8(%rsp), %rdi
callq 0x4b4e3
incq (%rax)
jmp 0x5df1e
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
pushq $0x10
popq %rdx
callq 0x4b801
testb %bl, %bl
je 0x5df1e
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x4b801
movq 0x10(%rsp), %rbp
movq 0x18(%rsp), %r12
incq %r13
jmp 0x5deb0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd0070(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6c114(%rip), %rsi     # 0xca066
leaq 0x7dc79(%rip), %rdx     # 0xdbbd2
leaq 0x7de76(%rip), %rcx     # 0xdbdd6
leaq 0x7d81f(%rip), %r8      # 0xdb786
movl $0x17f, %r9d            # imm = 0x17F
jmp 0x5df9b
movq 0xd0042(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6c0e6(%rip), %rsi     # 0xca066
leaq 0x7de63(%rip), %rdx     # 0xdbdea
leaq 0x7de48(%rip), %rcx     # 0xdbdd6
leaq 0x7d7f1(%rip), %r8      # 0xdb786
movl $0x180, %r9d            # imm = 0x180
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x4b380
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x5de48
movq %rax, %rbx
movq %r14, %rdi
callq 0x4ba50
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b903
movq %r15, %rdi
callq 0x4c19d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x4b988
movq %rax, %r15
cmpq %rax, %rbx
jae 0x5e056
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b48e
movq (%rax), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b48e
cmpq 0x8(%rax), %r12
ja 0x5e068
testq %rbx, %rbx
je 0x5e051
leaq -0x1(%rbx), %rsi
movq %r14, %rdi
callq 0x4b48e
movq 0x8(%rax), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4b48e
cmpq (%rax), %r12
jae 0x5e056
incq %rbx
jmp 0x5dffd
cmpq %r15, %rbx
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xcff49(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6bfed(%rip), %rsi     # 0xca066
leaq 0x7dbc4(%rip), %rdx     # 0xdbc44
leaq 0x7dc16(%rip), %rcx     # 0xdbc9d
leaq 0x7d6f8(%rip), %r8      # 0xdb786
movl $0x1c8, %r9d            # imm = 0x1C8
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5e0e3
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x4b988
cmpq %rax, %r15
jae 0x5e0da
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4b48e
addq 0x8(%rax), %r14
subq (%rax), %r14
incq %r14
incq %r15
jmp 0x5e0b3
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xcfece(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6bf72(%rip), %rsi     # 0xca066
leaq 0x8725f(%rip), %rdx     # 0xe535a
leaq 0x7dbb5(%rip), %rcx     # 0xdbcb7
leaq 0x7d67d(%rip), %r8      # 0xdb786
movl $0x1d8, %r9d            # imm = 0x1D8
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5e15a
movq %rdi, %rbx
callq 0x4b4dc
movq (%rax), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x4b4e3
movq 0x8(%rax), %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x5d05e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0xcfe57(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6befb(%rip), %rsi     # 0xca066
leaq 0x871e8(%rip), %rdx     # 0xe535a
leaq 0x7db55(%rip), %rcx     # 0xdbcce
leaq 0x7d606(%rip), %r8      # 0xdb786
movl $0x1e3, %r9d            # imm = 0x1E3
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5e35f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x5e35f
movq %rdi, %r14
callq 0x4b4dc
movq (%rax), %rax
cmpq (%rbx), %rax
jae 0x5e344
xorl %eax, %eax
jmp 0x5e357
movq %r14, %rdi
callq 0x4b4e3
movq 0x8(%rax), %rax
cmpq 0x8(%rbx), %rax
setbe %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xcfc52(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6bcf6(%rip), %rsi     # 0xca066
leaq 0x7da15(%rip), %rdx     # 0xdbd8c
leaq 0x7da1f(%rip), %rcx     # 0xdbd9d
leaq 0x7d401(%rip), %r8      # 0xdb786
movl $0x20a, %r9d            # imm = 0x20A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/range.c
// Function: gt_ranges_show
void gt_ranges_show(GtArray *ranges, GtFile *outfp)
{
  GtRange *range;
  GtUword i;
  gt_assert(ranges);
  for (i = 0; i < gt_array_size(ranges); i++) {
    range = gt_array_get(ranges, i);
    gt_file_xprintf(outfp, "("GT_WU","GT_WU")", range->start, range->end);
  }
  gt_file_xfputc('\n', outfp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x5e3fb
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x7da1b(%rip), %r15     # 0xdbdcc
xorl %r12d, %r12d
movq %r14, %rdi
callq 0x4b988
cmpq %rax, %r12
jae 0x5e3e5
movq %r14, %rdi
movq %r12, %rsi
callq 0x4b48e
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x542da
incq %r12
jmp 0x5e3b4
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x54619
movq 0xcfbb6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6bc5a(%rip), %rsi     # 0xca066
leaq 0x86f47(%rip), %rdx     # 0xe535a
leaq 0x7d9a3(%rip), %rcx     # 0xdbdbd
leaq 0x7d365(%rip), %r8      # 0xdb786
movl $0x21b, %r9d            # imm = 0x21B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/safearith.c
// Function: gt_safe_mult_u32_check_func
uint32_t gt_safe_mult_u32_check_func(uint32_t a, uint32_t b,
                                     const char *src_file, int src_line,
                                     GtOverflowHandlerFunc handler_func,
                                     void *data)
{
  GtUint64 x = (GtUint64) a * b;
  if (x > 0xffffffff) { /* overflow */
    handler_func(src_file, src_line, data);
  }
  return x;
}

// Assembly:
pushq %rbx
movq %rdx, %r10
movl %edi, %eax
mull %esi
movl %eax, %ebx
jno 0x5e48f
movq %r10, %rdi
movl %ecx, %esi
movq %r9, %rdx
callq *%r8
movl %ebx, %eax
popq %rbx
retq