LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x31f90(%rip), %rsi     # 0x10a170
movl $0x1f8, %edi            # imm = 0x1F8
movl $0x33, %edx
callq 0x35ee2
xorl %ecx, %ecx
movl %ecx, 0x1e0(%rax)
movl %ecx, 0x1ef(%rax)
movq $0x0, 0x1e8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x31f58(%rip), %rsi     # 0x10a170
movl $0x1f8, %edi            # imm = 0x1F8
movl $0x33, %edx
callq 0x35ee2
movq %rax, %r14
xorl %eax, %eax
movl %eax, 0x1e0(%r14)
movl %eax, 0x1ef(%r14)
movq $0x0, 0x1e8(%r14)
movq %rbx, %rdi
callq 0x722dc
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_O1/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 0xd82a7
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 0x83628
leaq 0x30(%rbx), %rsi
xorl %edi, %edi
callq 0x83628
movl $0x0, 0x1e0(%rbx)
popq %rbx
retq
callq 0x32ea0
// File: /workspace/github_c_makefile_star2_O1/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 0xd82e3
movq %rdi, %rbx
cmpl $0x0, 0x1e0(%rdi)
jne 0xd82e1
leaq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0xba20
leaq 0x150(%rbx), %rsi
xorl %edi, %edi
callq 0x83628
movl $0x1, 0x1e0(%rbx)
popq %rbx
retq
callq 0x32ed7
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x1e0(%rdi)
jne 0xd830d
movq %r15, %rdi
callq 0xd82ac
cmpl $0x1, 0x1e0(%r15)
jne 0xd8368
leaq 0x20(%r15), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0xd836d
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 0x32f0e
// File: /workspace/github_c_makefile_star2_O1/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(%rdx), %r9
movq %r9, %rax
movabsq $0x431bde82d7b634db, %r8 # imm = 0x431BDE82D7B634DB
subq 0x8(%rsi), %rax
jle 0xd83ae
imulq %r8
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, (%rcx)
movq 0x8(%rsi), %rax
movq 0x8(%rcx), %r9
subq %r9, %rax
cmpq $0xf4241, %rax          # imm = 0xF4241
jl 0xd83e7
mulq %r8
shrq $0x12, %rdx
movabsq $0xf424000000000, %rax  # imm = 0xF424000000000
imulq %rdx, %rax
sarq $0x20, %rax
addq %r9, %rax
movq %rax, 0x8(%rcx)
movslq %edx, %rax
subq %rax, (%rcx)
movdqu (%rsi), %xmm0
movdqu (%rcx), %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x1e0(%rdi)
jne 0xd8413
movq %rbx, %rdi
callq 0xd82ac
cmpl $0x1, 0x1e0(%rbx)
jne 0xd8443
leaq 0x20(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xd836d
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x32f47
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x1e0(%rdi)
jne 0xd8470
movq %r15, %rdi
callq 0xd82ac
cmpl $0x1, 0x1e0(%r15)
jne 0xd84e8
leaq 0x20(%r15), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0xd836d
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 0x3c067
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x32f80
// File: /workspace/github_c_makefile_star2_O1/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 0xd8564
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 0xd85a0
testq %rdx, %rdx
je 0xd85a0
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 0xd85a5
addq $0xd8, %rsp
retq
callq 0x32fb9
// File: /workspace/github_c_makefile_star2_O1/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 0xd86d0
testq %rdx, %rdx
je 0xd86d0
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 0x83628
leaq 0x10(%rbx), %r12
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xd836d
leaq 0xc0(%rbx), %r13
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xd836d
leaq 0x160(%rbx), %rsi
leaq 0xd0(%rbx), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xd836d
movq 0x1e8(%rbx), %r8
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq 0x10(%rsp), %r9
callq 0xd86d5
movq 0x1e8(%rbx), %rdi
testq %rdi, %rdi
je 0xd867f
leaq 0x31afb(%rip), %rsi     # 0x10a170
movl $0x114, %edx            # imm = 0x114
callq 0x362a0
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 0x722dc
movq %rax, 0x1e8(%rbx)
movq %r12, %rdi
xorl %esi, %esi
callq 0xba20
xorl %edi, %edi
movq %r13, %rsi
callq 0x83628
addq $0x2058, %rsp           # imm = 0x2058
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x32ff2
// File: /workspace/github_c_makefile_star2_O1/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 %r9, %rbx
movq %r8, %r9
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq (%rsi), %rcx
movabsq $0x346dc5d63886594b, %rax # imm = 0x346DC5D63886594B
imulq 0x8(%rsi)
movq %rdx, %r8
shrq $0x3f, %r8
sarq $0xb, %rdx
addq %rdx, %r8
leaq 0x31b57(%rip), %rsi     # 0x10a269
movq %rbx, %rdi
movq %r9, %rdx
xorl %eax, %eax
callq 0xb8d0
cmpb $0x1, 0x1f2(%r12)
jne 0xd8783
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 0x31b12(%rip), %rsi     # 0x10a27d
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_O1/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, %rbx
movq %rdi, %r14
movabsq $0x6c6c617265766f, %rax # imm = 0x6C6C617265766F
movq %rax, 0x8(%rsp)
callq 0xd82ac
cmpb $0x0, 0x1f1(%r14)
jne 0xd8832
leaq 0x20(%r14), %rsi
leaq 0x10(%r14), %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0xd836d
leaq 0x150(%r14), %rsi
leaq 0xc0(%r14), %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xd836d
leaq 0x160(%r14), %rsi
leaq 0xd0(%r14), %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0xd836d
movq 0x1e8(%r14), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r9
callq 0xd86d5
leaq 0x20(%r14), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xd836d
leaq 0x150(%r14), %rsi
leaq 0x30(%r14), %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xd836d
leaq 0x160(%r14), %rsi
leaq 0x40(%r14), %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0xd836d
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r9
callq 0xd86d5
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd88e8
pushq %rbx
movq %rdi, %rbx
movq 0x1e8(%rdi), %rdi
testq %rdi, %rdi
je 0xd88d3
leaq 0x318a7(%rip), %rsi     # 0x10a170
movl $0x14d, %edx            # imm = 0x14D
callq 0x362a0
leaq 0x31896(%rip), %rsi     # 0x10a170
movq %rbx, %rdi
movl $0x14e, %edx            # imm = 0x14E
popq %rbx
jmp 0x362a0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x3d23c
movq %rax, %rbx
movl $0x8, %r12d
callq 0x3bfe0
movq %rax, %r14
leaq 0x79e6e(%rip), %r13     # 0x152780
leaq 0x239ef(%rip), %r15     # 0xfc308
movq %r14, %rdi
callq 0x3c49c
movl (%r12,%r13), %esi
movq %r14, %rdi
callq 0x3c3be
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c067
movq -0x8(%r12,%r13), %rsi
movq %r14, %rdi
callq 0x3c067
movq %r14, %rdi
callq 0x3c40b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d318
addq $0x20, %r12
cmpq $0x268, %r12            # imm = 0x268
jne 0xd8919
movq %r14, %rdi
callq 0x3d1eb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movl %edi, %edx
cmpl $0x1a, %edi
jae 0xd89ae
movl $0x1e0181, %eax         # imm = 0x1E0181
btq %rdx, %rax
jb 0xd89ae
cmpl $0x13, %edx
je 0xd89ed
movl %edx, %eax
leaq 0x31bc5(%rip), %rcx     # 0x10a560
movl (%rcx,%rax,4), %eax
shlq $0x5, %rax
leaq 0x79dd7(%rip), %rbx     # 0x152780
addq %rax, %rbx
jmp 0xd89c4
leaq 0x32886(%rip), %rax     # 0x10b23b
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x3559f
testq %rbx, %rbx
je 0xd89e9
leaq 0x31d00(%rip), %rdx     # 0x10a6d0
movl $0x1, %edi
movl $0x8, %esi
movl $0x30b, %ecx            # imm = 0x30B
callq 0x3601f
movq %rbx, (%rax)
jmp 0xd89eb
xorl %eax, %eax
popq %rbx
retq
callq 0x3302b
// File: /workspace/github_c_makefile_star2_O1/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 0xd8a9e
movq %r8, %rbx
testq %r8, %r8
je 0xd8a9e
movq %r9, %r14
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
testq %r9, %r9
je 0xd8a63
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xd8aa3
movq (%r13), %rax
movq 0x10(%rax), %rdi
movzbl %r12b, %esi
movzbl %r15b, %edx
movzbl %bpl, %ecx
xorl %r15d, %r15d
xorl %r8d, %r8d
movq %r14, %r9
callq 0xd8aa8
movb %al, (%rbx)
cmpb $0x1, %al
sbbl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3309d
callq 0x330d6
// File: /workspace/github_c_makefile_star2_O1/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 0xd8c7d
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 0xd8aa8
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 0x3310f
// File: /workspace/github_c_makefile_star2_O1/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 0xd8cab
movq (%rdi), %rax
movq 0x10(%rax), %rdi
movzbl %sil, %esi
movzbl %dl, %edx
movzbl %cl, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xd8aa8
cmpb $0x2a, %al
sete %al
popq %rcx
retq
callq 0x33148
// File: /workspace/github_c_makefile_star2_O1/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 0x3c03d
movq %rax, %r13
movzbl %r12b, %r9d
movq %r15, %rdi
movl %r14d, %esi
movq %rax, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0xd9225
movq %rax, %rbx
movq %r13, %rdi
callq 0x3d1eb
movq (%rsp), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4c337
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x71d9b
cmpq $0x0, 0x79c42(%rip)     # 0x152d98
jne 0xd9187
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0xd9195
leaq 0x64(%rip), %rcx        # 0xd91d2
movl $0x40, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x49b7c
movq %rax, 0x79c11(%rip)     # 0x152d98
callq 0x71db1
movq 0x79c05(%rip), %rax     # 0x152d98
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9148
movq %rax, %rdi
movq %rbx, %rsi
callq 0x49c1d
testq %rax, %rax
je 0xd91cd
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x3d1eb
movq 0x20(%rbx), %rdi
callq 0xdbbc3
movq 0x28(%rbx), %rdi
popq %rbx
jmp 0xa886e
callq 0x331ba
// File: /workspace/github_c_makefile_star2_O1/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 0xd9148
movq %rax, %rdi
movq %r15, %rsi
callq 0x49c1d
movq %rax, %r15
testq %rbx, %rbx
je 0xd9204
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xd9220
leaq 0xd3(%rip), %rdx        # 0xd92de
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x4068e
callq 0x331f1
// File: /workspace/github_c_makefile_star2_O1/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 0xd9148
movq %rax, %rdi
callq 0x49bec
movq %rax, %rbx
callq 0xd9148
movq %rax, %rdi
movq %rbx, %rsi
callq 0x49c1d
movq %rax, %rbp
movl %r13d, 0x10(%rax)
movq %r12, %rdi
callq 0x3c561
movq %rax, 0x18(%rbp)
callq 0xdb700
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_O1/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 0xd9a90
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xd9b51
testq %r15, %r15
je 0xd9b4c
leaq 0x22ee2(%rip), %rsi     # 0xfc982
movq %r15, %rdi
callq 0x40409
xorl %ebp, %ebp
testb %al, %al
je 0xd9b3b
movq %r15, %rdi
callq 0x3fdd2
testl %eax, %eax
je 0xd9acb
movq %r15, %rdi
callq 0x3fdd2
cmpl $0x1, %eax
jne 0xd9b3b
movq %r15, %rdi
callq 0x41f83
movq 0x28(%rbx), %rbp
testq %rbp, %rbp
je 0xd9b56
movq %rax, %r12
movq %rdx, %r13
movq %r15, %rdi
callq 0x41f3f
movq %rsp, %rsi
movq %rbp, %rdi
movq %rax, %rdx
movq %r12, %rcx
movq %r13, %r8
movq %r14, %r9
callq 0xa8a31
movl %eax, %ebp
testl %eax, %eax
jne 0xd9b3b
testq %r12, %r12
je 0xd9b5b
testq %r13, %r13
je 0xd9b5b
movq 0x20(%rbx), %rdi
movq (%rsp), %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0xdb739
movq (%rsp), %rdi
leaq 0x317c6(%rip), %rsi     # 0x10b2f5
movl $0x4e, %edx
callq 0x362a0
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x334ca
callq 0x33425
callq 0x33493
callq 0x3345c
// File: /workspace/github_c_makefile_star2_O1/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 0x71d9b
cmpq $0x0, 0x79216(%rip)     # 0x152da0
jne 0xd9bab
leaq 0x26(%rip), %rsi        # 0xd9bb9
leaq 0x49(%rip), %rdx        # 0xd9be3
movl $0x20, %edi
callq 0x498b0
movq %rax, 0x791f5(%rip)     # 0x152da0
callq 0x71db1
movq 0x791e9(%rip), %rax     # 0x152da0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xd9c08
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0xd9ca1
callq 0xd9b7c
movq %rax, %rdi
movq %r14, %rsi
callq 0x49b60
movq %rax, %r14
movq 0x18(%rax), %rdi
callq 0xda034
testq %rax, %rax
jne 0xd9c86
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x499e4
testl %eax, %eax
jne 0xd9c5a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xd9c5e
movq 0x18(%r14), %rsi
movq %r15, %rdx
callq 0x42036
testl %eax, %eax
jne 0xd9c5a
movq 0x18(%r14), %rdi
jmp 0xd9c1f
movl %eax, %ebp
jmp 0xd9c60
xorl %ebp, %ebp
testl %ebp, %ebp
jne 0xd9c94
cmpq $0x0, (%rbx)
jne 0xd9ca6
movq 0x18(%r14), %rdi
movl $0x1, %esi
callq 0xda070
movq 0x18(%r14), %rdi
callq 0xda034
testq %rax, %rax
je 0xd9c94
movq 0x18(%r14), %rdi
callq 0xda052
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x33538
callq 0x3356f
// File: /workspace/github_c_makefile_star2_O1/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 0xd9b7c
movq %rax, %r15
movq %r14, %rdi
callq 0x49b4d
movzbl %al, %esi
movq %r15, %rdi
callq 0x498e8
movq %rax, %r15
callq 0xd9b7c
movq %rax, %rdi
movq %r15, %rsi
callq 0x49b60
movq %rax, %r12
movq %r14, %rdi
callq 0x49954
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0xd9fcd
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x71d9b
cmpq $0x0, 0x79086(%rip)     # 0x152da8
jne 0xd9d72
leaq 0x26a(%rip), %rax       # 0xd9f95
movq %rax, (%rsp)
leaq 0x4a(%rip), %rsi        # 0xd9d80
leaq 0x76(%rip), %rdx        # 0xd9db3
leaq 0x79(%rip), %rcx        # 0xd9dbd
leaq 0x212(%rip), %r8        # 0xd9f5d
leaq 0x215(%rip), %r9        # 0xd9f67
movl $0x68, %edi
callq 0x49b7c
movq %rax, 0x79045(%rip)     # 0x152da8
leaq 0x259(%rip), %rsi       # 0xd9fc3
movq %rax, %rdi
callq 0x49bdc
callq 0x71db1
movq 0x7902a(%rip), %rax     # 0x152da8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd9d14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x49c1d
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x7c623
movq 0x20(%rbx), %rdi
callq 0x6f134
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x3d1eb
// File: /workspace/github_c_makefile_star2_O1/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 0xd9d14
movq %rax, %rdi
callq 0x49bec
movq %rax, %rbx
callq 0xd9d14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x49c1d
movq %rax, %r15
callq 0x7c028
movq %rax, 0x10(%r15)
movq %r14, 0x18(%r15)
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x20(%r15)
movq $0x0, 0x28(%r15)
leaq 0x31472(%rip), %rdi     # 0x10b494
callq 0x3c03d
movq %rax, 0x60(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xda995
movq (%rsi), %r14
testq %r14, %r14
je 0xda995
movq %rdi, %rbx
leaq 0x31f53(%rip), %rsi     # 0x10c8a0
movq %r14, %rdi
callq 0x40409
testb %al, %al
je 0xda995
leaq 0x8c(%rip), %rdx        # 0xda9ec
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4068e
testl %eax, %eax
jne 0xda99a
movq %rbx, %rdi
callq 0x6ecda
testq %rax, %rax
je 0xda99f
movq %rbx, %rdi
callq 0x7eb00
testb %al, %al
je 0xda9a4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x33a84
callq 0x33abd
callq 0x33b2f
callq 0x33af6
// File: /workspace/github_c_makefile_star2_O1/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 0xda9c4
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0xda9e7
callq 0xd9d14
movq %rax, %rdi
movq %r14, %rsi
callq 0x49c1d
movq 0x10(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7c043
callq 0x33b68
// File: /workspace/github_c_makefile_star2_O1/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 0xdaa0a
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0xdaa57
testq %r14, %r14
je 0xdaa52
testq %rbx, %rbx
je 0xdaa52
leaq 0x21f67(%rip), %rsi     # 0xfc982
movq %r14, %rdi
callq 0x40409
testb %al, %al
je 0xdaa48
movq %r14, %rdi
callq 0x41f83
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movl $0x10, %edx
movq %rbx, %rdi
callq 0x6ec0e
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x33bd8
callq 0x33b9f
// File: /workspace/github_c_makefile_star2_O1/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 0xdab3f
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
ja 0xdab44
testq %rax, %rax
je 0xdab1d
movq %rcx, %xmm1
movq 0x699e(%rip), %xmm2     # 0xe1480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x69a2(%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 0xdab25
movsd 0x6dcb(%rip), %xmm0     # 0xe18f0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xdab49
movsd 0x6db9(%rip), %xmm1     # 0xe18f0
ucomisd %xmm0, %xmm1
jb 0xdab49
popq %rax
retq
callq 0x33d5b
callq 0x33d24
callq 0x33ced
// File: /workspace/github_c_makefile_star2_O1/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 0xdabcf
movq (%rdi), %rcx
movq 0x10(%rdi), %rax
cmpq %rax, %rcx
ja 0xdabd4
testq %rax, %rax
je 0xdabad
movq %rcx, %xmm1
movq 0x690e(%rip), %xmm2     # 0xe1480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x6912(%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 0xdabb5
movsd 0x6d3b(%rip), %xmm0     # 0xe18f0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xdabd9
movsd 0x6d29(%rip), %xmm1     # 0xe18f0
ucomisd %xmm0, %xmm1
jb 0xdabd9
popq %rax
retq
callq 0x33e00
callq 0x33dc9
callq 0x33d92
// File: /workspace/github_c_makefile_star2_O1/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 0xdac19
movq %rsi, %rbx
movq %rdi, %r14
callq 0xdaabe
mulsd 0x10bc6(%rip), %xmm0    # 0xeb7c0
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0x30ec1(%rip), %rsi     # 0x10bac9
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x757a1
callq 0x33e37
// File: /workspace/github_c_makefile_star2_O1/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 0xdac59
movq %rsi, %rbx
movq %rdi, %r14
callq 0xdab4e
mulsd 0x10b86(%rip), %xmm0    # 0xeb7c0
movq (%r14), %rdx
movq 0x10(%r14), %rcx
leaq 0x30e81(%rip), %rsi     # 0x10bac9
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x757a1
callq 0x33e6e
// File: /workspace/github_c_makefile_star2_O1/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 0x71d9b
cmpq $0x0, 0x77806(%rip)     # 0x152db0
jne 0xdb5cb
leaq 0x26(%rip), %rsi        # 0xdb5d9
leaq 0x49(%rip), %rdx        # 0xdb603
movl $0x20, %edi
callq 0x498b0
movq %rax, 0x777e5(%rip)     # 0x152db0
callq 0x71db1
movq 0x777d9(%rip), %rax     # 0x152db0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdb622
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xdb66b
callq 0xdb59c
movq %rax, %rdi
movq %r15, %rsi
callq 0x49b60
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x499e4
testl %eax, %eax
je 0xdb64e
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
testq %rdi, %rdi
je 0xdb667
movq 0x18(%r15), %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x42036
xorl %eax, %eax
jmp 0xdb648
callq 0x33f13
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_out_stream.c
// Function: gt_gff3_out_stream_new
GtNodeStream* gt_gff3_out_stream_new(GtNodeStream *in_stream, GtFile *outfp)
{
  GtNodeStream *ns = gt_node_stream_create(gt_gff3_out_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtGFF3OutStream *gff3_out_stream = gff3_out_stream_cast(ns);
  gff3_out_stream->in_stream = gt_node_stream_ref(in_stream);
  gff3_out_stream->gff3_visitor = gt_gff3_visitor_new(outfp);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xdb59c
movq %rax, %r15
movq %r14, %rdi
callq 0x49b4d
movzbl %al, %esi
movq %r15, %rdi
callq 0x498e8
movq %rax, %r15
callq 0xdb59c
movq %rax, %rdi
movq %r15, %rsi
callq 0x49b60
movq %rax, %r12
movq %r14, %rdi
callq 0x49954
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x48588
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_O1/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_new
Splicedseq* gt_splicedseq_new(void)
{
  Splicedseq *ss = gt_malloc(sizeof (Splicedseq));
  ss->splicedseq = gt_str_new();
  ss->positionmapping = gt_array_new(sizeof (GtUword));
  ss->forward = true;
  return ss;
}

// Assembly:
pushq %rbx
leaq 0x30684(%rip), %rsi     # 0x10bd8c
movl $0x18, %edi
movl $0x22, %edx
callq 0x35ee2
movq %rax, %rbx
callq 0x3bfe0
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq