LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/sig.c
// Function: gt_sig_unregister_all
void gt_sig_unregister_all(void)
{
  /* POSIX */
  (void) gt_xsignal(SIGABRT, SIG_DFL);
  (void) gt_xsignal(SIGFPE, SIG_DFL);
  (void) gt_xsignal(SIGILL, SIG_DFL);
  (void) gt_xsignal(SIGINT, SIG_DFL);
  (void) gt_xsignal(SIGSEGV, SIG_DFL);
  (void) gt_xsignal(SIGTERM, SIG_DFL);
#ifndef _WIN32
  (void) gt_xsignal(SIGBUS, SIG_DFL);
  (void) gt_xsignal(SIGHUP, SIG_DFL);
  (void) gt_xsignal(SIGPIPE, SIG_DFL);
  (void) gt_xsignal(SIGQUIT, SIG_DFL);
  (void) gt_xsignal(SIGTSTP, SIG_DFL);
  (void) gt_xsignal(SIGTTIN, SIG_DFL);
  (void) gt_xsignal(SIGTTOU, SIG_DFL);
  (void) gt_xsignal(SIGUSR1, SIG_DFL);
  (void) gt_xsignal(SIGUSR2, SIG_DFL);
  (void) gt_xsignal(SIGSYS, SIG_DFL);
  (void) gt_xsignal(SIGXCPU, SIG_DFL);
  (void) gt_xsignal(SIGXFSZ, SIG_DFL);
#endif

  /* OpenBSD */
#ifdef SIGEMT
  (void) gt_xsignal(SIGEMT, SIG_DFL);
#endif
}

// Assembly:
pushq %rax
movl $0x6, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x8, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x4, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x2, %edi
xorl %esi, %esi
callq 0x832e6
movl $0xb, %edi
xorl %esi, %esi
callq 0x832e6
movl $0xf, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x7, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x1, %edi
xorl %esi, %esi
callq 0x832e6
movl $0xd, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x3, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x14, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x15, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x16, %edi
xorl %esi, %esi
callq 0x832e6
movl $0xa, %edi
xorl %esi, %esi
callq 0x832e6
movl $0xc, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x1f, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x18, %edi
xorl %esi, %esi
callq 0x832e6
movl $0x19, %edi
xorl %esi, %esi
popq %rax
jmp 0x832e6
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_new
GtTimer* gt_timer_new(void)
{
  GtTimer *t = gt_malloc(sizeof *t);
  t->state = TIMER_RUNNING;
  t->statedesc = NULL;
  t->has_desc = false;
  t->omit_last_stage = false;
  t->show_cpu_time = false;
  return t;
}

// Assembly:
pushq %rax
leaq 0x316d0(%rip), %rsi     # 0x109f90
movl $0x1f8, %edi            # imm = 0x1F8
movl $0x33, %edx
callq 0x35862
xorl %ecx, %ecx
movl %ecx, 0x1e0(%rax)
movl %ecx, 0x1ef(%rax)
movq $0x0, 0x1e8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_new_with_progress_description
GtTimer* gt_timer_new_with_progress_description(const char* desc)
{
  GtTimer *t = gt_timer_new();
  t->statedesc = gt_cstr_dup(desc);
  t->has_desc = true;
  return t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x31698(%rip), %rsi     # 0x109f90
movl $0x1f8, %edi            # imm = 0x1F8
movl $0x33, %edx
callq 0x35862
movq %rax, %r14
xorl %eax, %eax
movl %eax, 0x1e0(%r14)
movl %eax, 0x1ef(%r14)
movq $0x0, 0x1e8(%r14)
movq %rbx, %rdi
callq 0x728c0
movq %rax, 0x1e8(%r14)
movb $0x1, 0x1f0(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_start
void gt_timer_start(GT_WIN32_UNUSED GtTimer *t)
{
#ifndef _WIN32
  gt_assert(t);
  gettimeofday(&t->gstart_tv, NULL);
  gettimeofday(&t->start_tv, NULL);
  gt_xgetrusage(RUSAGE_SELF, &t->start_ru);
  gt_xgetrusage(RUSAGE_SELF, &t->gstart_ru);
  t->state = TIMER_RUNNING;
#else
  /* XXX */
  fprintf(stderr, "gt_timer_start() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xd8987
movq %rdi, %rbx
xorl %esi, %esi
callq 0xba20
leaq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0xba20
leaq 0xc0(%rbx), %rsi
xorl %edi, %edi
callq 0x83210
leaq 0x30(%rbx), %rsi
xorl %edi, %edi
callq 0x83210
movl $0x0, 0x1e0(%rbx)
popq %rbx
retq
callq 0x328a3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_stop
void gt_timer_stop(GT_WIN32_UNUSED GtTimer *t)
{
  gt_assert(t);
#ifndef _WIN32
  if (t->state == TIMER_RUNNING) {
    gettimeofday(&t->stop_tv, NULL);
    gt_xgetrusage(RUSAGE_SELF, &t->stop_ru);
    t->state = TIMER_STOPPED;
  }
#else
  /* XXX */
  fprintf(stderr, "gt_timer_stop() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xd89c3
movq %rdi, %rbx
cmpl $0x0, 0x1e0(%rdi)
jne 0xd89c1
leaq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0xba20
leaq 0x150(%rbx), %rsi
xorl %edi, %edi
callq 0x83210
movl $0x1, 0x1e0(%rbx)
popq %rbx
retq
callq 0x328da
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_show_formatted
void gt_timer_show_formatted(GT_WIN32_UNUSED GtTimer *t,
                             GT_WIN32_UNUSED const char *fmt,
                             GT_WIN32_UNUSED FILE *fp)
{
#ifndef _WIN32
  struct timeval elapsed_tv;
  if (t->state == TIMER_RUNNING)
    gt_timer_stop(t);
  gt_assert(t->state == TIMER_STOPPED);
  timeval_subtract(&elapsed_tv, &t->stop_tv, &t->gstart_tv);
  fprintf(fp, fmt,
          (GtWord)(elapsed_tv.tv_sec),
          (GtWord)(elapsed_tv.tv_usec),
          (GtWord)(t->stop_ru.ru_utime.tv_sec - t->start_ru.ru_utime.tv_sec),
          (GtWord)(t->stop_ru.ru_stime.tv_sec - t->start_ru.ru_stime.tv_sec));
#else
  /* XXX */
  fprintf(stderr, "gt_timer_show_formatted() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x1e0(%rdi), %eax
testl %eax, %eax
jne 0xd89f5
movq %r15, %rdi
callq 0xd898c
movl 0x1e0(%r15), %eax
cmpl $0x1, %eax
jne 0xd8a4b
leaq 0x20(%r15), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0xd8a50
movq (%r12), %rdx
movq 0x150(%r15), %r8
movq 0x160(%r15), %r9
subq 0xc0(%r15), %r8
subq 0xd0(%r15), %r9
movq 0x8(%r12), %rcx
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb8d0
callq 0x32911
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: timeval_subtract
static int timeval_subtract(struct timeval *result,
                            struct timeval *x,
                            struct timeval *y)
{
  if (x->tv_usec < y->tv_usec) {
    int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
    y->tv_usec -= 1000000 * nsec;
    y->tv_sec += nsec;
  }
  if (x->tv_usec - y->tv_usec > 1000000) {
    int nsec = (x->tv_usec - y->tv_usec) / 1000000;
    y->tv_usec += 1000000 * nsec;
    y->tv_sec -= nsec;
  }
  result->tv_sec = x->tv_sec - y->tv_sec;
  result->tv_usec = x->tv_usec - y->tv_usec;
  return x->tv_sec < y->tv_sec;
}

// Assembly:
movq %rdx, %rcx
movq 0x8(%rsi), %rax
movq (%rdx), %r8
movq 0x8(%rdx), %r9
movq %r9, %rdx
movabsq $0x431bde82d7b634db, %r10 # imm = 0x431BDE82D7B634DB
subq %rax, %rdx
jle 0xd8aa1
movq %rdx, %rax
imulq %r10
movq %rdx, %rax
shrq $0x12, %rax
shrq $0x3f, %rdx
addl %edx, %eax
incl %eax
imull $0xf4240, %eax, %edx    # imm = 0xF4240
movslq %edx, %rdx
subq %rdx, %r9
movq %r9, 0x8(%rcx)
cltq
addq %rax, %r8
movq %r8, (%rcx)
movq 0x8(%rsi), %rax
subq %r9, %rax
cmpq $0xf4241, %rax          # imm = 0xF4241
jl 0xd8adc
mulq %r10
shrq $0x12, %rdx
movabsq $0xf424000000000, %r10  # imm = 0xF424000000000
imulq %rdx, %r10
sarq $0x20, %r10
addq %r9, %r10
movq %r10, 0x8(%rcx)
movslq %edx, %rax
subq %rax, %r8
movq %r8, (%rcx)
movq 0x8(%rsi), %rax
subq %r10, %rax
movq (%rsi), %rcx
subq %r8, %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_elapsed_usec
GtWord gt_timer_elapsed_usec(GT_WIN32_UNUSED GtTimer *t)
{
#ifndef _WIN32
  struct timeval elapsed_tv;
  if (t->state == TIMER_RUNNING)
    gt_timer_stop(t);
  gt_assert(t->state == TIMER_STOPPED);
  timeval_subtract(&elapsed_tv, &t->stop_tv, &t->gstart_tv);
  return (GtWord) (elapsed_tv.tv_usec + elapsed_tv.tv_sec * 1000000L);
#else
  /* XXX */
  fprintf(stderr, "gt_elapsed_usec() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x1e0(%rdi), %eax
testl %eax, %eax
jne 0xd8b0c
movq %rbx, %rdi
callq 0xd898c
movl 0x1e0(%rbx), %eax
cmpl $0x1, %eax
jne 0xd8b38
leaq 0x20(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd8a50
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x3294a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_get_formatted
void gt_timer_get_formatted(GT_WIN32_UNUSED GtTimer *t,
                            GT_WIN32_UNUSED const char *fmt,
                            GT_WIN32_UNUSED GtStr *str)
{
#ifndef _WIN32
  struct timeval elapsed_tv;
  char buf[BUFSIZ];
  if (t->state == TIMER_RUNNING)
    gt_timer_stop(t);
  gt_assert(t->state == TIMER_STOPPED);
  timeval_subtract(&elapsed_tv, &t->stop_tv, &t->gstart_tv);
  (void) snprintf(buf, BUFSIZ-1, fmt,
          (GtWord)(elapsed_tv.tv_sec),
          (GtWord)(elapsed_tv.tv_usec),
          (GtWord)(t->stop_ru.ru_utime.tv_sec - t->start_ru.ru_utime.tv_sec),
          (GtWord)(t->stop_ru.ru_stime.tv_sec - t->start_ru.ru_stime.tv_sec));
  gt_str_append_cstr(str, buf);
#else
  /* XXX */
  fprintf(stderr, "gt_timer_get_formatted() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2028, %rsp           # imm = 0x2028
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x1e0(%rdi), %eax
testl %eax, %eax
jne 0xd8b6d
movq %r15, %rdi
callq 0xd898c
movl 0x1e0(%r15), %eax
cmpl $0x1, %eax
jne 0xd8be0
leaq 0x20(%r15), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0xd8a50
movq (%r12), %rcx
movq 0x8(%r12), %r8
movq 0x150(%r15), %r9
movq 0x160(%r15), %rax
subq 0xc0(%r15), %r9
subq 0xd0(%r15), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %r15
movl $0x1fff, %esi           # imm = 0x1FFF
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xba10
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b7af
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x32983
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_show_progress_formatted
void gt_timer_show_progress_formatted(GT_WIN32_UNUSED GtTimer *t,
                                      GT_WIN32_UNUSED FILE *fp,
                                      GT_WIN32_UNUSED const char *desc,
                                      ...)
{
#ifndef _WIN32
  va_list ap;
  gt_assert(t && desc);
  va_start(ap, desc);
  gt_timer_show_progress_va(t, fp, desc, ap);
  va_end(ap);
#else
  /* XXX */
  fprintf(stderr, "gt_timer_show_progress_formatted() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
subq $0xd8, %rsp
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0xd8c5c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
testq %rdi, %rdi
je 0xd8c98
testq %rdx, %rdx
je 0xd8c98
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
callq 0xd8c9d
addq $0xd8, %rsp
retq
callq 0x329bc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_show_progress_va
void gt_timer_show_progress_va(GT_WIN32_UNUSED GtTimer *t,
                               GT_WIN32_UNUSED FILE *fp,
                               GT_WIN32_UNUSED const char *desc,
                               GT_WIN32_UNUSED va_list ap)
{
#ifndef _WIN32
  char buf[BUFSIZ];
  struct timeval elapsed_tv, elapsed_user_tv, elapsed_sys_tv;
  gt_assert(t && desc);

  gettimeofday(&t->stop_tv, NULL);
  gt_xgetrusage(RUSAGE_SELF, &t->stop_ru);
  timeval_subtract(&elapsed_tv, &t->stop_tv, &t->start_tv);
  timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime,
    &t->start_ru.ru_utime);
  timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime,
    &t->start_ru.ru_stime);
  gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv,
    &elapsed_sys_tv, t->statedesc, fp);
  if (t->statedesc)
    gt_free(t->statedesc);
  (void) vsnprintf(buf, BUFSIZ, desc, ap);
  t->statedesc = gt_cstr_dup(buf);
  gettimeofday(&t->start_tv, NULL);
  gt_xgetrusage(RUSAGE_SELF, &t->start_ru);
#else
  /* XXX */
  fprintf(stderr, "gt_timer_show_progress_va() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2058, %rsp           # imm = 0x2058
movq %rcx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
testq %rdi, %rdi
je 0xd8dd1
testq %rdx, %rdx
je 0xd8dd1
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
leaq 0x20(%rdi), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0xba20
leaq 0x150(%rbx), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x83210
leaq 0x10(%rbx), %r12
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xd8a50
leaq 0xc0(%rbx), %r13
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xd8a50
leaq 0x160(%rbx), %rsi
leaq 0xd0(%rbx), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xd8a50
movq 0x1e8(%rbx), %r9
movq (%rbp), %rsi
movq 0x8(%rbp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rcx
movq %r14, %r8
callq 0xd8dd6
movq 0x1e8(%rbx), %rdi
testq %rdi, %rdi
je 0xd8d80
leaq 0x3121a(%rip), %rsi     # 0x109f90
movl $0x114, %edx            # imm = 0x114
callq 0x35c27
leaq 0x50(%rsp), %r14
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0xb3b0
movq %r14, %rdi
callq 0x728c0
movq %rax, 0x1e8(%rbx)
movq %r12, %rdi
xorl %esi, %esi
callq 0xba20
xorl %edi, %edi
movq %r13, %rsi
callq 0x83210
addq $0x2058, %rsp           # imm = 0x2058
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x329f5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_print_progress_report
static void gt_timer_print_progress_report(GtTimer *t,
    struct timeval *elapsed_tv, struct timeval *elapsed_user_tv,
    struct timeval *elapsed_sys_tv, const char *desc, FILE *fp)
{
  fprintf(fp,"# TIME %s "GT_WD".%02ld",
          desc,
          (GtWord)(elapsed_tv->tv_sec),
          (GtWord)(elapsed_tv->tv_usec)/10000);
  if (t->show_cpu_time) {
    fprintf(fp, " (user: "GT_WD".%02ld; sys: "GT_WD".%02ld)\n",
            (GtWord)(elapsed_user_tv->tv_sec),
            (GtWord)(elapsed_user_tv->tv_usec)/10000,
            (GtWord)(elapsed_sys_tv->tv_sec),
            (GtWord)(elapsed_sys_tv->tv_usec)/10000);
  }
  else {
    fprintf(fp, "\n");
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rax
movq %rsi, %rcx
movq %rdi, %r12
movq 0x30(%rsp), %rbx
movabsq $0x346dc5d63886594b, %rdx # imm = 0x346DC5D63886594B
imulq %rdx
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0xb, %rdx
addq %rdx, %r8
leaq 0x31275(%rip), %rsi     # 0x10a089
movq %rbx, %rdi
movq %r9, %rdx
xorl %eax, %eax
callq 0xb8d0
cmpb $0x1, 0x1f2(%r12)
jne 0xd8e85
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %rsi, %rax
imulq 0x8(%r15)
movq (%r15), %r10
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0xb, %rdx
addq %rdx, %rcx
movq (%r14), %r8
movq %rsi, %rax
imulq 0x8(%r14)
movq %rdx, %r9
shrq $0x3f, %r9
sarq $0xb, %rdx
addq %rdx, %r9
leaq 0x31230(%rip), %rsi     # 0x10a09d
movq %rbx, %rdi
movq %r10, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb8d0
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb7d0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_show_progress_final
void gt_timer_show_progress_final(GT_WIN32_UNUSED GtTimer *t,
                                  GT_WIN32_UNUSED FILE *fp)
{
#ifndef _WIN32
  struct timeval elapsed_tv, elapsed_user_tv, elapsed_sys_tv;
  const char overall_desc[] = "overall";

  gt_timer_stop(t);
  if (!t->omit_last_stage) {
    timeval_subtract(&elapsed_tv, &t->stop_tv, &t->start_tv);
    timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime,
      &t->start_ru.ru_utime);
    timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime,
      &t->start_ru.ru_stime);
    gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv,
      &elapsed_sys_tv, t->statedesc, fp);
  }
  timeval_subtract(&elapsed_tv, &t->stop_tv, &t->gstart_tv);
  timeval_subtract(&elapsed_user_tv, &t->stop_ru.ru_utime,
    &t->gstart_ru.ru_utime);
  timeval_subtract(&elapsed_sys_tv, &t->stop_ru.ru_stime,
    &t->gstart_ru.ru_stime);
  gt_timer_print_progress_report(t, &elapsed_tv, &elapsed_user_tv,
    &elapsed_sys_tv, overall_desc, fp);
#else
  /* XXX */
  fprintf(stderr, "gt_timer_show_progress_final() not implemented\n");
  exit(EXIT_FAILURE);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movabsq $0x6c6c617265766f, %rax # imm = 0x6C6C617265766F
movq %rax, 0x8(%rsp)
callq 0xd898c
cmpb $0x0, 0x1f1(%rbx)
jne 0xd8f38
leaq 0x20(%rbx), %rsi
leaq 0x10(%rbx), %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0xd8a50
leaq 0x150(%rbx), %rsi
leaq 0xc0(%rbx), %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xd8a50
leaq 0x160(%rbx), %rsi
leaq 0xd0(%rbx), %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0xd8a50
movq 0x1e8(%rbx), %r9
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, (%rsp)
movq %rbx, %rdi
movq %r12, %rcx
movq %r13, %r8
callq 0xd8dd6
leaq 0x20(%rbx), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rdx
callq 0xd8a50
leaq 0x150(%rbx), %rsi
leaq 0x30(%rbx), %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xd8a50
leaq 0x160(%rbx), %rsi
leaq 0x40(%rbx), %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0xd8a50
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, (%rsp)
leaq 0x8(%rsp), %r9
movq %rbx, %rdi
movq %r12, %rcx
movq %r13, %r8
callq 0xd8dd6
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/timer.c
// Function: gt_timer_delete
void gt_timer_delete(GtTimer *t)
{
  if (!t) return;
  if (t->statedesc)
    gt_free(t->statedesc);
  gt_free(t);
}

// Assembly:
testq %rdi, %rdi
je 0xd8ff3
pushq %rbx
movq %rdi, %rbx
movq 0x1e8(%rdi), %rdi
testq %rdi, %rdi
je 0xd8fde
leaq 0x30fbc(%rip), %rsi     # 0x109f90
movl $0x14d, %edx            # imm = 0x14D
callq 0x35c27
leaq 0x30fab(%rip), %rsi     # 0x109f90
movq %rbx, %rdi
movl $0x14e, %edx            # imm = 0x14E
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/trans_table.c
// Function: gt_trans_table_get_scheme_descriptions
GtStrArray* gt_trans_table_get_scheme_descriptions()
{
  GtUword i;
  GtTranslationScheme *scheme;
  GtStr *str;
  GtStrArray *sa = gt_str_array_new();
  str = gt_str_new();
  for (i = 0UL; i < (GtUword) GT_NUMOFTRANSSCHEMES; i++) {
    scheme = schemetable+i;
    gt_str_reset(str);
    gt_str_append_uint(str, scheme->identity);
    gt_str_append_cstr(str, ": ");
    gt_str_append_cstr(str, scheme->name);
    gt_str_array_add_cstr(sa, gt_str_get(str));
  }
  gt_str_delete(str);
  return sa;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
callq 0x3c8cc
movq %rax, %rbx
movl $0x8, %r12d
callq 0x3b728
movq %rax, %r14
leaq 0x79766(%rip), %r13     # 0x152780
leaq 0x23257(%rip), %r15     # 0xfc278
movq %r14, %rdi
callq 0x3bbee
movl (%r12,%r13), %esi
movq %r14, %rdi
callq 0x3bb10
movq %r14, %rdi
movq %r15, %rsi
callq 0x3b7af
movq -0x8(%r12,%r13), %rsi
movq %r14, %rdi
callq 0x3b7af
movq %r14, %rdi
callq 0x3bb5d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3c9a5
addq $0x20, %r12
cmpq $0x268, %r12            # imm = 0x268
jne 0xd9021
movq %r14, %rdi
callq 0x3c87b
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/trans_table.c
// Function: gt_trans_table_new
GtTransTable* gt_trans_table_new(unsigned int scheme, GtError *err)
{
  GtTranslationScheme *schemep;
  GtTransTable *tt;
  if (!(schemep = getschemetable(scheme, err)))
    return NULL;
  tt = gt_calloc((size_t) 1, sizeof (GtTransTable));
  tt->scheme = schemep;
  return tt;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %edx
cmpl $0x1a, %edi
jae 0xd90da
movl $0x1e0181, %eax         # imm = 0x1E0181
btq %rdx, %rax
jb 0xd90da
cmpl $0x13, %edx
je 0xd90fb
movl %edx, %eax
leaq 0x312da(%rip), %rcx     # 0x10a380
movl (%rcx,%rax,4), %eax
shlq $0x5, %rax
leaq 0x796cc(%rip), %r14     # 0x152780
addq %rax, %r14
leaq 0x31432(%rip), %rdx     # 0x10a4f0
movl $0x1, %edi
movl $0x8, %esi
movl $0x30b, %ecx            # imm = 0x30B
callq 0x359a6
movq %rax, %rbx
movq %r14, (%rax)
jmp 0xd90f0
leaq 0x31f7a(%rip), %rax     # 0x10b05b
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x34f1f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x32a2e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/trans_table.c
// Function: gt_trans_table_translate_codon
int gt_trans_table_translate_codon(const GtTransTable *tt,
                                   char c1, char c2, char c3,
                                   char *amino, GtError *err)
{
  gt_assert(tt && amino);
  gt_error_check(err);
  *amino = codon2amino(tt->scheme->aminos, true,
                       (unsigned char) c1,
                       (unsigned char) c2,
                       (unsigned char) c3,
                        NULL, err);
  if (*amino == GT_AMINOACIDFAIL) {
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd91c5
movq %r8, %rbx
testq %r8, %r8
je 0xd91c5
movq %r9, %r14
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
testq %r9, %r9
je 0xd918d
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xd91ca
movq (%r13), %rax
movq 0x10(%rax), %rdi
movzbl %r12b, %esi
movzbl %r15b, %edx
movzbl %bpl, %ecx
xorl %r8d, %r8d
movq %r14, %r9
jmp 0xd91a7
movq (%r13), %rax
movq 0x10(%rax), %rdi
movzbl %r12b, %esi
movzbl %r15b, %edx
movzbl %bpl, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xd91cf
movb %al, (%rbx)
xorl %ecx, %ecx
cmpb $0x1, %al
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x32aa0
callq 0x32ad9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/trans_table.c
// Function: gt_trans_table_is_start_codon
bool gt_trans_table_is_start_codon(const GtTransTable *tt,
                                   char c1, char c2, char c3)
{
  unsigned int code = 0;
  gt_assert(tt);
  (void) codon2amino(tt->scheme->aminos, true,
                     (unsigned char) c1,
                     (unsigned char) c2,
                     (unsigned char) c3,
                     &code, NULL);
  if (tt->scheme->startcodon[code] == GT_START_AMINO) {
    return true;
  }
  return false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x0, 0x4(%rsp)
testq %rdi, %rdi
je 0xd93ad
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x10(%rax), %rdi
movzbl %sil, %esi
movzbl %dl, %edx
movzbl %cl, %ecx
leaq 0x4(%rsp), %r14
movq %r14, %r8
xorl %r9d, %r9d
callq 0xd91cf
movq (%rbx), %rax
movq 0x18(%rax), %rax
movl (%r14), %ecx
cmpb $0x4d, (%rax,%rcx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x32b12
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/trans_table.c
// Function: gt_trans_table_is_stop_codon
bool gt_trans_table_is_stop_codon(const GtTransTable *tt,
                                  char c1, char c2, char c3)
{
  char trans;
  gt_assert(tt);
  trans = codon2amino(tt->scheme->aminos, true,
                      (unsigned char) c1,
                      (unsigned char) c2,
                      (unsigned char) c3,
                      NULL, NULL);
  if (trans == GT_STOP_AMINO) {
    return true;
  }
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xd93db
movq (%rdi), %rax
movq 0x10(%rax), %rdi
movzbl %sil, %esi
movzbl %dl, %edx
movzbl %cl, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xd91cf
cmpb $0x2a, %al
sete %al
popq %rcx
retq
callq 0x32b4b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/cds_stream.c
// Function: gt_cds_stream_new
GtNodeStream* gt_cds_stream_new(GtNodeStream *in_stream, GtRegionMapping *rm,
                                unsigned int minorflen, const char *source,
                                bool start_codon, bool final_stop_codon,
                                bool generic_start_codons)
{
  GtNodeVisitor *nv;
  GtStr *source_str;
  source_str = gt_str_new_cstr(source);
  nv = gt_cds_visitor_new(rm, minorflen, source_str, start_codon,
                          final_stop_codon, generic_start_codons);
  gt_str_delete(source_str);
  return gt_visitor_stream_new(in_stream, nv);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, (%rsp)
movb 0x40(%rsp), %r12b
movq %rcx, %rdi
callq 0x3b785
movq %rax, %r13
movzbl %r12b, %r9d
movq %r15, %rdi
movl %r14d, %esi
movq %rax, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0xd98fd
movq %rax, %rbx
movq %r13, %rdi
callq 0x3c87b
movq (%rsp), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4b6e1
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/cds_visitor.c
// Function: gt_cds_visitor_class
const GtNodeVisitorClass* gt_cds_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtCDSVisitor),
                                    cds_visitor_free,
                                    NULL,
                                    cds_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x72367
cmpq $0x0, 0x7956a(%rip)     # 0x152d98
jne 0xd985f
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0xd986d
leaq 0x64(%rip), %rcx        # 0xd98aa
movl $0x40, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x48f24
movq %rax, 0x79539(%rip)     # 0x152d98
callq 0x7237d
movq 0x7952d(%rip), %rax     # 0x152d98
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/cds_visitor.c
// Function: cds_visitor_free
static void cds_visitor_free(GtNodeVisitor *nv)
{
  GtCDSVisitor *cds_visitor = gt_cds_visitor_cast(nv);
  gt_assert(cds_visitor);
  gt_str_delete(cds_visitor->source);
  gt_splicedseq_delete(cds_visitor->splicedseq);
  gt_region_mapping_delete(cds_visitor->region_mapping);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xd9820
movq %rax, %rdi
movq %rbx, %rsi
callq 0x48fc5
testq %rax, %rax
je 0xd98a5
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x3c87b
movq 0x20(%rbx), %rdi
callq 0xdc288
movq 0x28(%rbx), %rdi
popq %rbx
jmp 0xa7eb2
callq 0x32bbd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/cds_visitor.c
// Function: cds_visitor_feature_node
static int cds_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                                    GtError *err)
{
  GtCDSVisitor *v = gt_cds_visitor_cast(nv);
  gt_error_check(err);
  return gt_feature_node_traverse_children(fn, v, add_cds_if_necessary, false,
                                           err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xd9820
movq %rax, %rdi
movq %r15, %rsi
callq 0x48fc5
movq %rax, %r15
testq %rbx, %rbx
je 0xd98dc
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xd98f8
leaq 0xd3(%rip), %rdx        # 0xd99b6
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x3fd29
callq 0x32bf4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/cds_visitor.c
// Function: gt_cds_visitor_new
GtNodeVisitor* gt_cds_visitor_new(GtRegionMapping *region_mapping,
                                  unsigned int minorflen, GtStr *source,
                                  bool start_codon, bool final_stop_codon,
                                  bool generic_start_codons)
{
  GtNodeVisitor *nv;
  GtCDSVisitor *cds_visitor;
  nv = gt_node_visitor_create(gt_cds_visitor_class());
  cds_visitor = gt_cds_visitor_cast(nv);
  cds_visitor->minorflen = minorflen;
  cds_visitor->source = gt_str_ref(source);
  cds_visitor->splicedseq = gt_splicedseq_new();
  cds_visitor->region_mapping = region_mapping;
  cds_visitor->start_codon = start_codon;
  cds_visitor->final_stop_codon = final_stop_codon;
  cds_visitor->generic_start_codons = generic_start_codons;
  return nv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, (%rsp)
movl %ecx, %r14d
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r15
callq 0xd9820
movq %rax, %rdi
callq 0x48f94
movq %rax, %rbx
callq 0xd9820
movq %rax, %rdi
movq %rbx, %rsi
callq 0x48fc5
movq %rax, %rbp
movl %r13d, 0x10(%rax)
movq %r12, %rdi
callq 0x3bcaf
movq %rax, 0x18(%rbp)
callq 0xdbdbc
movq %rax, 0x20(%rbp)
movq %r15, 0x28(%rbp)
movb %r14b, 0x38(%rbp)
movl (%rsp), %eax
movb %al, 0x39(%rbp)
movl 0x4(%rsp), %eax
movb %al, 0x3a(%rbp)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/cds_visitor.c
// Function: extract_cds_if_necessary
static int extract_cds_if_necessary(GtFeatureNode *fn, void *data,
                                    GtError *err)
{
  GtCDSVisitor *v = (GtCDSVisitor*) data;
  GtRange range;
  char *outsequence;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(fn);

  if (gt_feature_node_has_type(fn, gt_ft_exon) &&
      (gt_feature_node_get_strand(fn) == GT_STRAND_FORWARD ||
       gt_feature_node_get_strand(fn) == GT_STRAND_REVERSE)) {
    range = gt_genome_node_get_range((GtGenomeNode*) fn);
    gt_assert(v->region_mapping);
    had_err = gt_region_mapping_get_sequence(v->region_mapping, &outsequence,
                                   gt_genome_node_get_seqid((GtGenomeNode*) fn),
                                   range.start, range.end, err);
    if (!had_err) {
      gt_assert(range.start && range.end); /* 1-based coordinates */
      gt_splicedseq_add(v->splicedseq, range.start, range.end, outsequence);
      gt_free(outsequence);
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0xda184
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xda245
testq %r15, %r15
je 0xda240
leaq 0x2275e(%rip), %rsi     # 0xfc8f2
movq %r15, %rdi
callq 0x3faa4
xorl %ebp, %ebp
testb %al, %al
je 0xda22f
movq %r15, %rdi
callq 0x3f462
testl %eax, %eax
je 0xda1bf
movq %r15, %rdi
callq 0x3f462
cmpl $0x1, %eax
jne 0xda22f
movq %r15, %rdi
callq 0x415e5
movq 0x28(%rbx), %rbp
testq %rbp, %rbp
je 0xda24a
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
callq 0x415a1
movq %rsp, %rsi
movq %rbp, %rdi
movq %rax, %rdx
movq %r12, %rcx
movq %r13, %r8
movq %r14, %r9
callq 0xa8075
movl %eax, %ebp
testl %eax, %eax
jne 0xda22f
testq %r12, %r12
je 0xda24f
testq %r13, %r13
je 0xda24f
movq 0x20(%rbx), %rdi
movq (%rsp), %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0xdbdf5
movq (%rsp), %rdi
leaq 0x30ef2(%rip), %rsi     # 0x10b115
movl $0x4e, %edx
callq 0x35c27
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x32ecd
callq 0x32e28
callq 0x32e96
callq 0x32e5f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/csa_stream.c
// Function: gt_csa_stream_class
const GtNodeStreamClass* gt_csa_stream_class(void)
{
  static const GtNodeStreamClass *nsc= NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtCSAStream),
                                   csa_stream_free,
                                   csa_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x72367
cmpq $0x0, 0x78b22(%rip)     # 0x152da0
jne 0xda29f
leaq 0x26(%rip), %rsi        # 0xda2ad
leaq 0x49(%rip), %rdx        # 0xda2d7
movl $0x20, %edi
callq 0x48c48
movq %rax, 0x78b01(%rip)     # 0x152da0
callq 0x7237d
movq 0x78af5(%rip), %rax     # 0x152da0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/csa_stream.c
// Function: csa_stream_next
static int csa_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err)
{
  GtCSAStream *cs;
  int had_err;
  gt_error_check(err);
  cs = csa_stream_cast(ns);

  /* we have still nodes in the buffer */
  if (gt_csa_visitor_node_buffer_size(cs->csa_visitor)) {
    *gn = gt_csa_visitor_get_node(cs->csa_visitor); /* return one of them */
    return 0;
  }

  /* no nodes in the buffer -> get new nodes */
  while (!(had_err = gt_node_stream_next(cs->in_stream, gn, err)) && *gn) {
    gt_assert(*gn && !had_err);
    had_err = gt_genome_node_accept(*gn, cs->csa_visitor, err);
    if (had_err)
      break;
    if (gt_csa_visitor_node_buffer_size(cs->csa_visitor)) {
      *gn = gt_csa_visitor_get_node(cs->csa_visitor);
      return 0;
    }
  }

  /* either we have an error or no new node */
  gt_assert(had_err || !*gn);

  /* if we have no error, process the last cluster */
  if (!had_err) {
    gt_csa_visitor_process_cluster(cs->csa_visitor, true);
    if (gt_csa_visitor_node_buffer_size(cs->csa_visitor)) {
      *gn = gt_csa_visitor_get_node(cs->csa_visitor);
      return 0;
    }
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0xda2fa
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xda37b
callq 0xda270
movq %rax, %rdi
movq %r15, %rsi
callq 0x48f0b
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0xda6fd
testq %rax, %rax
jne 0xda367
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x48d7c
testl %eax, %eax
jne 0xda375
movq (%rbx), %rdi
movq 0x18(%r15), %rsi
testq %rdi, %rdi
je 0xda34c
movq %r14, %rdx
callq 0x41698
testl %eax, %eax
jne 0xda375
movq 0x18(%r15), %rdi
jmp 0xda311
movq %rsi, %rdi
movl $0x1, %esi
callq 0xda739
movq 0x18(%r15), %rdi
callq 0xda6fd
testq %rax, %rax
je 0xda373
movq 0x18(%r15), %rdi
callq 0xda71b
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x32f3b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/csa_stream.c
// Function: gt_csa_stream_new
GtNodeStream* gt_csa_stream_new(GtNodeStream *in_stream,
                                GtUword join_length)
{
  GtNodeStream *ns = gt_node_stream_create(gt_csa_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtCSAStream *cs = csa_stream_cast(ns);
  cs->in_stream = gt_node_stream_ref(in_stream);
  cs->csa_visitor = gt_csa_visitor_new(join_length);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xda270
movq %rax, %r15
movq %r14, %rdi
callq 0x48ef8
movzbl %al, %esi
movq %r15, %rdi
callq 0x48c80
movq %rax, %r15
callq 0xda270
movq %rax, %rdi
movq %r15, %rsi
callq 0x48f0b
movq %rax, %r12
movq %r14, %rdi
callq 0x48cec
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0xda696
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/csa_visitor.c
// Function: gt_csa_visitor_class
const GtNodeVisitorClass* gt_csa_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (CSAVisitor),
                                    csa_visitor_free,
                                    csa_visitor_comment_node,
                                    csa_visitor_feature_node,
                                    csa_visitor_region_node,
                                    csa_visitor_sequence_node,
                                    csa_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc, csa_visitor_meta_node);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x72367
cmpq $0x0, 0x789b2(%rip)     # 0x152da8
jne 0xda446
leaq 0x25f(%rip), %rax       # 0xda65e
movq %rax, (%rsp)
leaq 0x4a(%rip), %rsi        # 0xda454
leaq 0x76(%rip), %rdx        # 0xda487
leaq 0x79(%rip), %rcx        # 0xda491
leaq 0x207(%rip), %r8        # 0xda626
leaq 0x20a(%rip), %r9        # 0xda630
movl $0x68, %edi
callq 0x48f24
movq %rax, 0x78971(%rip)     # 0x152da8
leaq 0x24e(%rip), %rsi       # 0xda68c
movq %rax, %rdi
callq 0x48f84
callq 0x7237d
movq 0x78956(%rip), %rax     # 0x152da8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/csa_visitor.c
// Function: csa_visitor_free
static void csa_visitor_free(GtNodeVisitor *nv)
{
  CSAVisitor *csa_visitor = csa_visitor_cast(nv);
  gt_queue_delete(csa_visitor->gt_genome_node_buffer);
  gt_array_delete(csa_visitor->cluster);
  gt_str_delete(csa_visitor->gt_csa_source_str);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xda3e8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x48fc5
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x7ca47
movq 0x20(%rbx), %rdi
callq 0x6f768
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x3c87b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/csa_visitor.c
// Function: gt_csa_visitor_new
GtNodeVisitor* gt_csa_visitor_new(GtUword join_length)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_csa_visitor_class());
  CSAVisitor *csa_visitor = csa_visitor_cast(nv);
  csa_visitor->gt_genome_node_buffer = gt_queue_new();
  csa_visitor->join_length = join_length;
  csa_visitor->cluster = gt_array_new(sizeof (GtFeatureNode*));
  csa_visitor->buffered_feature = NULL;
  csa_visitor->gt_csa_source_str = gt_str_new_cstr(GT_CSA_SOURCE_TAG);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0xda3e8
movq %rax, %rdi
callq 0x48f94
movq %rax, %rbx
callq 0xda3e8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x48fc5
movq %rax, %r15
callq 0x7c464
movq %rax, 0x10(%r15)
movq %r14, 0x18(%r15)
movl $0x8, %edi
callq 0x6ef7c
movq %rax, 0x20(%r15)
movq $0x0, 0x28(%r15)
leaq 0x30bc9(%rip), %rdi     # 0x10b2b4
callq 0x3b785
movq %rax, 0x60(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/csa_visitor.c
// Function: get_exons
static void get_exons(GtArray *exon_ranges, const void *sa)
{
  GtFeatureNode *fn = *(GtFeatureNode**) sa;
  GT_UNUSED int had_err;
  gt_assert(exon_ranges && fn && gt_feature_node_has_type(fn, gt_ft_gene));
  had_err = gt_feature_node_traverse_children(fn, exon_ranges,
                                              csa_visitor_save_exon, false,
                                              NULL);
  gt_assert(!had_err); /* csa_visitor_save_exon() is sane */
  /* we got at least one exon */
  gt_assert(gt_array_size(exon_ranges));
  gt_assert(gt_ranges_are_sorted_and_do_not_overlap(exon_ranges));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xdb050
movq (%rsi), %r14
testq %r14, %r14
je 0xdb050
movq %rdi, %rbx
leaq 0x316b8(%rip), %rsi     # 0x10c6c0
movq %r14, %rdi
callq 0x3faa4
testb %al, %al
je 0xdb050
leaq 0x8c(%rip), %rdx        # 0xdb0a7
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3fd29
testl %eax, %eax
jne 0xdb055
movq %rbx, %rdi
callq 0x6f310
testq %rax, %rax
je 0xdb05a
movq %rbx, %rdi
callq 0x7eb8d
testb %al, %al
je 0xdb05f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x33450
callq 0x33489
callq 0x334fb
callq 0x334c2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/csa_visitor.c
// Function: csa_visitor_default_func
static int csa_visitor_default_func(GtNodeVisitor *nv, GtGenomeNode *gn,
                                    GT_UNUSED GtError *err)
{
  CSAVisitor *csa_visitor;
  gt_error_check(err);
  csa_visitor = csa_visitor_cast(nv);
  gt_queue_add(csa_visitor->gt_genome_node_buffer, gn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xdb07f
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0xdb0a2
callq 0xda3e8
movq %rax, %rdi
movq %r14, %rsi
callq 0x48fc5
movq 0x10(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7c47f
callq 0x33534
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/csa_visitor.c
// Function: csa_visitor_save_exon
static int csa_visitor_save_exon(GtFeatureNode *fn, void *data,
                                 GT_UNUSED GtError *err)
{
  GtArray *exon_ranges = (GtArray*) data;
  GtRange range;
  gt_error_check(err);
  gt_assert(fn && exon_ranges);
  if (gt_feature_node_has_type(fn, gt_ft_exon)) {
    range = gt_genome_node_get_range((GtGenomeNode*) fn);
    gt_array_add(exon_ranges, range);
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xdb0c5
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0xdb112
testq %r14, %r14
je 0xdb10d
testq %rbx, %rbx
je 0xdb10d
leaq 0x2181c(%rip), %rsi     # 0xfc8f2
movq %r14, %rdi
callq 0x3faa4
testb %al, %al
je 0xdb103
movq %r14, %rdi
callq 0x415e5
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0x10, %edx
movq %rbx, %rdi
callq 0x6f240
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x335a4
callq 0x3356b
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_get_sensitivity
double gt_evaluator_get_sensitivity(const GtEvaluator *evaluator)
{
  double sensitivity = 1.0;
  gt_assert(evaluator);
  gt_assert(evaluator->T <= evaluator->A);
  if (evaluator->A)
    sensitivity = (double) evaluator->T / evaluator->A;
  gt_assert(sensitivity >= 0.0 && sensitivity <= 1.0);
  return sensitivity;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xdb1fb
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
ja 0xdb200
testq %rax, %rax
je 0xdb1d9
movq %rcx, %xmm1
movq 0x62e2(%rip), %xmm2     # 0xe1480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x62e6(%rip), %xmm3     # 0xe1490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0xdb1e1
movsd 0x670f(%rip), %xmm0     # 0xe18f0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xdb205
movsd 0x66fd(%rip), %xmm1     # 0xe18f0
ucomisd %xmm0, %xmm1
jb 0xdb205
popq %rax
retq
callq 0x33727
callq 0x336f0
callq 0x336b9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_get_specificity
double gt_evaluator_get_specificity(const GtEvaluator *evaluator)
{
  double specificity = 1.0;
  gt_assert(evaluator);
  gt_assert(evaluator->T <= evaluator->P);
  if (evaluator->P)
    specificity = (double) evaluator->T / evaluator->P;
  gt_assert(specificity >= 0.0 && specificity <= 1.0);
  return specificity;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xdb28b
movq (%rdi), %rcx
movq 0x10(%rdi), %rax
cmpq %rax, %rcx
ja 0xdb290
testq %rax, %rax
je 0xdb269
movq %rcx, %xmm1
movq 0x6252(%rip), %xmm2     # 0xe1480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x6256(%rip), %xmm3     # 0xe1490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0xdb271
movsd 0x667f(%rip), %xmm0     # 0xe18f0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xdb295
movsd 0x666d(%rip), %xmm1     # 0xe18f0
ucomisd %xmm0, %xmm1
jb 0xdb295
popq %rax
retq
callq 0x337cc
callq 0x33795
callq 0x3375e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_show_sensitivity
void gt_evaluator_show_sensitivity(const GtEvaluator *evaluator, GtFile *outfp)
{
  gt_assert(evaluator);
  gt_file_xprintf(outfp, "%6.2f%% ("GT_WU"/"GT_WU")",
                  gt_evaluator_get_sensitivity(evaluator) * 100.0,
                  evaluator->T, evaluator->A);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xdb2d5
movq %rsi, %rbx
movq %rdi, %r14
callq 0xdb17a
mulsd 0x104ba(%rip), %xmm0    # 0xeb770
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0x30625(%rip), %rsi     # 0x10b8e9
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x75ce5
callq 0x33803
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_show_specificity
void gt_evaluator_show_specificity(const GtEvaluator *evaluator, GtFile *outfp)
{
  gt_assert(evaluator);
  gt_file_xprintf(outfp, "%6.2f%% ("GT_WU"/"GT_WU")",
                  gt_evaluator_get_specificity(evaluator) * 100.0,
                  evaluator->T, evaluator->P);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xdb315
movq %rsi, %rbx
movq %rdi, %r14
callq 0xdb20a
mulsd 0x1047a(%rip), %xmm0    # 0xeb770
movq (%r14), %rdx
movq 0x10(%r14), %rcx
leaq 0x305e5(%rip), %rsi     # 0x10b8e9
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x75ce5
callq 0x3383a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_out_stream.c
// Function: gt_gff3_out_stream_class
const GtNodeStreamClass* gt_gff3_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtGFF3OutStream),
                                   gff3_out_stream_free,
                                   gff3_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x72367
cmpq $0x0, 0x7714a(%rip)     # 0x152db0
jne 0xdbc87
leaq 0x26(%rip), %rsi        # 0xdbc95
leaq 0x49(%rip), %rdx        # 0xdbcbf
movl $0x20, %edi
callq 0x48c48
movq %rax, 0x77129(%rip)     # 0x152db0
callq 0x7237d
movq 0x7711d(%rip), %rax     # 0x152db0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_out_stream.c
// Function: gff3_out_stream_next
static int gff3_out_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                GtError *err)
{
  GtGFF3OutStream *gff3_out_stream;
  int had_err;
  gt_error_check(err);
  gff3_out_stream = gff3_out_stream_cast(ns);
  had_err = gt_node_stream_next(gff3_out_stream->in_stream, gn, err);
  if (!had_err && *gn)
    had_err = gt_genome_node_accept(*gn, gff3_out_stream->gff3_visitor, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xdbcde
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xdbd27
callq 0xdbc58
movq %rax, %rdi
movq %r15, %rsi
callq 0x48f0b
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x48d7c
testl %eax, %eax
je 0xdbd0a
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
testq %rdi, %rdi
je 0xdbd23
movq 0x18(%r15), %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x41698
xorl %eax, %eax
jmp 0xdbd04
callq 0x338df