LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_md5_to_description
int gt_seq_col_md5_to_description(GtSeqCol *sc, GtStr *desc, GtStr *md5_seqid,
                                  GtError *err)
{
  gt_assert(sc && desc && md5_seqid);
  if (sc->c_class->md5_to_desc)
    return sc->c_class->md5_to_desc(sc, desc, md5_seqid, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xbfd54
testq %rsi, %rsi
je 0xbfd54
testq %rdx, %rdx
je 0xbfd54
movq (%rdi), %rax
movq 0x40(%rax), %rax
testq %rax, %rax
je 0xbfd51
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e25c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa300(%rip), %rsi      # 0xca066
leaq 0x3329a(%rip), %rdx     # 0xf3007
leaq 0x332ab(%rip), %rcx     # 0xf301f
leaq 0x33167(%rip), %r8      # 0xf2ee2
movl $0x91, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_md5_to_sequence_length
int gt_seq_col_md5_to_sequence_length(GtSeqCol *sc, GtUword *len,
                                      GtStr *md5_seqid, GtError *err)
{
  gt_assert(sc && len && md5_seqid);
  if (sc->c_class->md5_to_seqlen)
    return sc->c_class->md5_to_seqlen(sc, len, md5_seqid, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xbfdad
testq %rsi, %rsi
je 0xbfdad
testq %rdx, %rdx
je 0xbfdad
movq (%rdi), %rax
movq 0x48(%rax), %rax
testq %rax, %rax
je 0xbfdaa
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e203(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2a7(%rip), %rsi      # 0xca066
leaq 0x33277(%rip), %rdx     # 0xf303d
leaq 0x33287(%rip), %rcx     # 0xf3054
leaq 0x3310e(%rip), %r8      # 0xf2ee2
movl $0x9a, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_num_of_files
GtUword gt_seq_col_num_of_files(const GtSeqCol *sc)
{
  gt_assert(sc);
  if (sc->c_class->num_files)
    return sc->c_class->num_files(sc);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xbfdfc
movq (%rdi), %rax
movq 0x50(%rax), %rax
testq %rax, %rax
je 0xbfdf9
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e1b4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa258(%rip), %rsi      # 0xca066
leaq 0x2b21a(%rip), %rdx     # 0xeb02f
leaq 0x3325a(%rip), %rcx     # 0xf3076
leaq 0x330bf(%rip), %r8      # 0xf2ee2
movl $0xa2, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_num_of_seqs
GtUword gt_seq_col_num_of_seqs(const GtSeqCol *sc, GtUword filenum)
{
 gt_assert(sc);
  if (sc->c_class->num_seqs)
    return sc->c_class->num_seqs(sc, filenum);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xbfe4b
movq (%rdi), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0xbfe48
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e165(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa209(%rip), %rsi      # 0xca066
leaq 0x2b1cb(%rip), %rdx     # 0xeb02f
leaq 0x33223(%rip), %rcx     # 0xf308e
leaq 0x33070(%rip), %r8      # 0xf2ee2
movl $0xaa, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_md5_fingerprint
const char* gt_seq_col_get_md5_fingerprint(const GtSeqCol *sc,
                                           GtUword filenum,
                                           GtUword seqnum)
{
  gt_assert(sc);
  if (sc->c_class->get_md5)
    return sc->c_class->get_md5(sc, filenum, seqnum);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xbfe9a
movq (%rdi), %rax
movq 0x60(%rax), %rax
testq %rax, %rax
je 0xbfe97
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e116(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa1ba(%rip), %rsi      # 0xca066
leaq 0x2b17c(%rip), %rdx     # 0xeb02f
leaq 0x331eb(%rip), %rcx     # 0xf30a5
leaq 0x33021(%rip), %r8      # 0xf2ee2
movl $0xb4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_sequence
char* gt_seq_col_get_sequence(const GtSeqCol *sc, GtUword filenum,
                              GtUword seqnum,GtUword start,
                              GtUword end)
{
  gt_assert(sc);
  if (sc->c_class->get_seq)
    return sc->c_class->get_seq(sc, filenum, seqnum, start, end);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xbfee9
movq (%rdi), %rax
movq 0x68(%rax), %rax
testq %rax, %rax
je 0xbfee6
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e0c7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa16b(%rip), %rsi      # 0xca066
leaq 0x2b12d(%rip), %rdx     # 0xeb02f
leaq 0x331bb(%rip), %rcx     # 0xf30c4
leaq 0x32fd2(%rip), %r8      # 0xf2ee2
movl $0xbe, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_description
char* gt_seq_col_get_description(const GtSeqCol *sc, GtUword filenum,
                                 GtUword seqnum)
{
  gt_assert(sc);
  if (sc->c_class->get_seq)
    return sc->c_class->get_desc(sc, filenum, seqnum);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xbff3a
movq (%rdi), %rax
cmpq $0x0, 0x68(%rax)
je 0xbff37
movq 0x70(%rax), %rax
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e076(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa11a(%rip), %rsi      # 0xca066
leaq 0x2b0dc(%rip), %rdx     # 0xeb02f
leaq 0x33182(%rip), %rcx     # 0xf30dc
leaq 0x32f81(%rip), %r8      # 0xf2ee2
movl $0xc7, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_col.c
// Function: gt_seq_col_get_sequence_length
GtUword gt_seq_col_get_sequence_length(const GtSeqCol *sc,
                                             GtUword filenum,
                                             GtUword seqnum)
{
  gt_assert(sc);
  if (sc->c_class->get_seqlen)
    return sc->c_class->get_seqlen(sc, filenum, seqnum);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0xbff89
movq (%rdi), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0xbff86
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0x6e027(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0xa0cb(%rip), %rsi      # 0xca066
leaq 0x2b08d(%rip), %rdx     # 0xeb02f
leaq 0x3314e(%rip), %rcx     # 0xf30f7
leaq 0x32f32(%rip), %r8      # 0xf2ee2
movl $0xd1, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/seq_info_cache.c
// Function: gt_seq_info_cache_add
void gt_seq_info_cache_add(GtSeqInfoCache *sic, const char *key,
                           const GtSeqInfo *si)
{
  GtSeqInfo *si_dup;
  gt_assert(sic && key && si);
  gt_assert(!gt_seq_info_cache_get(sic, key));
  si_dup = gt_malloc(sizeof *si_dup);
  si_dup->filenum = si->filenum;
  si_dup->seqnum = si->seqnum;
  gt_hashmap_add(sic->cache, gt_cstr_dup(key), si_dup);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc00ca
movq %rsi, %rbx
testq %rsi, %rsi
je 0xc00ca
movq %rdx, %r15
testq %rdx, %rdx
je 0xc00ca
movq %rdi, %r14
movq %rbx, %rsi
callq 0xc0019
testq %rax, %rax
jne 0xc00f4
leaq 0x33085(%rip), %rsi     # 0xf3116
pushq $0x10
popq %rdi
pushq $0x34
popq %rdx
callq 0xccb0
movq %rax, %r12
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq (%r14), %r14
movq %rbx, %rdi
callq 0x4f8ae
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x55f31
movq 0x6dee7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f8b(%rip), %rsi      # 0xca066
leaq 0x33064(%rip), %rdx     # 0xf3146
leaq 0x3306e(%rip), %rcx     # 0xf3157
leaq 0x33026(%rip), %r8      # 0xf3116
pushq $0x32
jmp 0xc011c
movq 0x6debd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x9f61(%rip), %rsi      # 0xca066
leaq 0x33061(%rip), %rdx     # 0xf316d
leaq 0x33044(%rip), %rcx     # 0xf3157
leaq 0x32ffc(%rip), %r8      # 0xf3116
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sequence_buffer_plain.c
// Function: gt_sequence_buffer_plain_new
GtSequenceBuffer* gt_sequence_buffer_plain_new(const GtStrArray *sequences)
{
  GtSequenceBuffer *sb;
  GtSequenceBufferPlain *sbf;
  sb = gt_sequence_buffer_create(gt_sequence_buffer_plain_class());
  sbf = gt_sequence_buffer_plain_cast(sb);
  sb->pvt->filenametab = sequences;
  sb->pvt->filenum = 0;
  sbf->firstseqinfile = true;
  sbf->nextfile = true;
  sb->pvt->nextread = sb->pvt->nextfree = 0;
  sb->pvt->complete = false;
  sb->pvt->lastspeciallength = 0;
  return sb;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6d8e4(%rip), %r14     # 0x12dcd0
movq %r14, %rdi
callq 0x5e5f0
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x5e96e
movq 0x8(%r15), %rcx
movq %rbx, 0x70(%rcx)
andl $0x0, (%rcx)
movw $0x101, 0x10(%rax)      # imm = 0x101
movb $0x0, 0x18(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rcx)
andq $0x0, 0x60(%rcx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/sig.c
// Function: gt_sig_register_all
void gt_sig_register_all(void (*func)(int sigraised))
{
  /* POSIX */
  (void) gt_xsignal(SIGABRT, func);
  (void) gt_xsignal(SIGFPE, func);
  (void) gt_xsignal(SIGILL, func);
  (void) gt_xsignal(SIGINT, func);
  (void) gt_xsignal(SIGSEGV, func);
  (void) gt_xsignal(SIGTERM, func);
#ifndef _WIN32
  (void) gt_xsignal(SIGBUS, func);
  (void) gt_xsignal(SIGHUP, func);
  (void) gt_xsignal(SIGPIPE, func);
  (void) gt_xsignal(SIGQUIT, func);
  (void) gt_xsignal(SIGTSTP, func);
  (void) gt_xsignal(SIGTTIN, func);
  (void) gt_xsignal(SIGTTOU, func);
  (void) gt_xsignal(SIGUSR1, func);
  (void) gt_xsignal(SIGUSR2, func);
  (void) gt_xsignal(SIGSYS, func);
  (void) gt_xsignal(SIGXCPU, func);
  (void) gt_xsignal(SIGXFSZ, func);
#endif

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x6
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x8
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x4
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x2
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0xb
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0xf
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x7
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x1
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0xd
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x3
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x14
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x15
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x16
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0xc
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x1f
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x18
popq %rdi
movq %rbx, %rsi
callq 0x62597
pushq $0x19
popq %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x62597
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x6
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x8
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x4
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x2
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0xb
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0xf
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x7
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0xd
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x3
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x14
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x15
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x16
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0xa
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0xc
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x1f
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x18
popq %rdi
xorl %esi, %esi
callq 0x62597
pushq $0x19
popq %rdi
xorl %esi, %esi
popq %rax
jmp 0x62597
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x32c9a(%rip), %rsi     # 0xf3252
pushq $0x33
popq %rdx
movl $0x1f8, %edi            # imm = 0x1F8
callq 0xccb0
andl $0x0, 0x1e0(%rax)
andq $0x0, 0x1e8(%rax)
andl $0x0, 0x1ef(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0xc05b0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4f8ae
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_O2/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 0xc064b
movq %rdi, %rbx
xorl %esi, %esi
callq 0xba10
leaq 0x10(%rbx), %rdi
xorl %esi, %esi
callq 0xba10
leaq 0xc0(%rbx), %rsi
xorl %edi, %edi
callq 0x6238d
leaq 0x30(%rbx), %rsi
xorl %edi, %edi
callq 0x6238d
andl $0x0, 0x1e0(%rbx)
popq %rbx
retq
movq 0x6d966(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x9a0a(%rip), %rsi      # 0xca066
leaq 0x135eb(%rip), %rdx     # 0xd3c4e
leaq 0x32bf9(%rip), %rcx     # 0xf3263
leaq 0x32be1(%rip), %r8      # 0xf3252
pushq $0x47
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc06b8
movq %rdi, %rbx
cmpl $0x0, 0x1e0(%rdi)
jne 0xc06b6
leaq 0x20(%rbx), %rdi
xorl %esi, %esi
callq 0xba10
leaq 0x150(%rbx), %rsi
xorl %edi, %edi
callq 0x6238d
movl $0x1, 0x1e0(%rbx)
popq %rbx
retq
movq 0x6d8f9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x999d(%rip), %rsi      # 0xca066
leaq 0x1357e(%rip), %rdx     # 0xd3c4e
leaq 0x32b9b(%rip), %rcx     # 0xf3272
leaq 0x32b74(%rip), %r8      # 0xf3252
pushq $0x56
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc071b
movq %r15, %rdi
callq 0xc0681
movl 0x1e0(%r15), %eax
cmpl $0x1, %eax
jne 0xc0771
leaq 0x20(%r15), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0xc07a9
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 0xb8c0
movq 0x6d840(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x98e4(%rip), %rsi      # 0xca066
leaq 0x32af7(%rip), %rdx     # 0xf3280
leaq 0x32b0a(%rip), %rcx     # 0xf329a
leaq 0x32abb(%rip), %r8      # 0xf3252
movl $0x8f, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
subq %rax, %rdx
jle 0xc07eb
movl $0xf4240, %r10d         # imm = 0xF4240
movq %rdx, %rax
cqto
idivq %r10
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 0xc0829
movl $0xf4240, %r10d         # imm = 0xF4240
xorl %edx, %edx
divq %r10
movabsq $0xf424000000000, %rdx  # imm = 0xF424000000000
imulq %rax, %rdx
sarq $0x20, %rdx
addq %r9, %rdx
movq %rdx, 0x8(%rcx)
cltq
subq %rax, %r8
movq %r8, (%rcx)
movq 0x8(%rsi), %rax
subq %rdx, %rax
movq (%rsi), %rcx
subq %r8, %rcx
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc0859
movq %rbx, %rdi
callq 0xc0681
movl 0x1e0(%rbx), %eax
cmpl $0x1, %eax
jne 0xc0885
leaq 0x20(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rdx
callq 0xc07a9
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x6d72c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x97d0(%rip), %rsi      # 0xca066
leaq 0x329e3(%rip), %rdx     # 0xf3280
leaq 0x32a0e(%rip), %rcx     # 0xf32b2
leaq 0x329a7(%rip), %r8      # 0xf3252
movl $0xa3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc08ed
movq %r15, %rdi
callq 0xc0681
movl 0x1e0(%r15), %eax
cmpl $0x1, %eax
jne 0xc0960
leaq 0x20(%r15), %rsi
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0xc07a9
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 0xba00
movq %rbx, %rdi
movq %r15, %rsi
callq 0x13dd3
addq $0x2028, %rsp           # imm = 0x2028
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x6d651(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x96f5(%rip), %rsi      # 0xca066
leaq 0x32908(%rip), %rdx     # 0xf3280
leaq 0x32949(%rip), %rcx     # 0xf32c8
leaq 0x328cc(%rip), %r8      # 0xf3252
movl $0xb6, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc0a0f
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 0xc0a4b
testq %rdx, %rdx
je 0xc0a4b
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 0xc0a83
addq $0xd8, %rsp
retq
movq 0x6d566(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x960a(%rip), %rsi      # 0xca066
leaq 0x328a3(%rip), %rdx     # 0xf3306
leaq 0x328a6(%rip), %rcx     # 0xf3310
leaq 0x327e1(%rip), %r8      # 0xf3252
movl $0xf5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc0bae
testq %rdx, %rdx
je 0xc0bae
movq %rdi, %rbx
movq %rdx, 0x8(%rsp)
leaq 0x20(%rdi), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0xba10
leaq 0x150(%rbx), %r14
xorl %edi, %edi
movq %r14, %rsi
callq 0x6238d
leaq 0x10(%rbx), %r12
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xc07a9
leaq 0xc0(%rbx), %r13
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xc07a9
leaq 0x160(%rbx), %rsi
leaq 0xd0(%rbx), %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xc07a9
movq 0x1e8(%rbx), %r8
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq 0x10(%rsp), %r9
callq 0xc0be6
movq 0x1e8(%rbx), %rdi
testq %rdi, %rdi
je 0xc0b5d
leaq 0x326ff(%rip), %rsi     # 0xf3252
movl $0x114, %edx            # imm = 0x114
callq 0xd249
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 0x4f8ae
movq %rax, 0x1e8(%rbx)
movq %r12, %rdi
xorl %esi, %esi
callq 0xba10
xorl %edi, %edi
movq %r13, %rsi
callq 0x6238d
addq $0x2058, %rsp           # imm = 0x2058
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6d403(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x94a7(%rip), %rsi      # 0xca066
leaq 0x32740(%rip), %rdx     # 0xf3306
leaq 0x32764(%rip), %rcx     # 0xf3331
leaq 0x3267e(%rip), %r8      # 0xf3252
movl $0x108, %r9d            # imm = 0x108
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movl $0x2710, %r13d          # imm = 0x2710
cqto
idivq %r13
leaq 0x32737(%rip), %rsi     # 0xf334b
movq %r9, %rdi
movq %r8, %rdx
movq %rax, %r8
xorl %eax, %eax
callq 0xb8c0
cmpb $0x1, 0x1f2(%r12)
jne 0xc0c6d
movq (%r15), %rcx
movq 0x8(%r15), %rax
cqto
idivq %r13
movq %rax, %r9
movq (%r14), %r8
movq 0x8(%r14), %rax
cqto
idivq %r13
leaq 0x3270e(%rip), %rsi     # 0xf335f
movq %rbx, %rdi
movq %rcx, %rdx
movq %r9, %rcx
movq %rax, %r9
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb8c0
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb7d0
// File: /workspace/github_c_makefile_star2_O2/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 0xc0681
cmpb $0x0, 0x1f1(%r14)
jne 0xc0d18
leaq 0x20(%r14), %rsi
leaq 0x10(%r14), %rdx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0xc07a9
leaq 0x150(%r14), %rsi
leaq 0xc0(%r14), %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xc07a9
leaq 0x160(%r14), %rsi
leaq 0xd0(%r14), %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0xc07a9
movq 0x1e8(%r14), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r9
callq 0xc0be6
leaq 0x20(%r14), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0xc07a9
leaq 0x150(%r14), %rsi
leaq 0x30(%r14), %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xc07a9
leaq 0x160(%r14), %rsi
leaq 0x40(%r14), %rdx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0xc07a9
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r9
callq 0xc0be6
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc0dce
pushq %rbx
movq %rdi, %rbx
movq 0x1e8(%rdi), %rdi
testq %rdi, %rdi
je 0xc0db9
leaq 0x324a3(%rip), %rsi     # 0xf3252
movl $0x14d, %edx            # imm = 0x14D
callq 0xd249
leaq 0x32492(%rip), %rsi     # 0xf3252
movq %rbx, %rdi
movl $0x14e, %edx            # imm = 0x14E
popq %rbx
jmp 0xd249
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1532c
movq %rax, %rbx
pushq $0x8
popq %r12
callq 0x13d5c
movq %rax, %r14
leaq 0x6e97c(%rip), %r13     # 0x12f770
leaq 0x247a9(%rip), %r15     # 0xe55a4
cmpq $0x268, %r12            # imm = 0x268
je 0xc0e49
movq %r14, %rdi
callq 0x1452f
movl (%r12,%r13), %esi
movq %r14, %rdi
callq 0x14329
movq %r14, %rdi
movq %r15, %rsi
callq 0x13dd3
movq -0x8(%r12,%r13), %rsi
movq %r14, %rdi
callq 0x13dd3
movq %r14, %rdi
callq 0x143d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x15407
addq $0x20, %r12
jmp 0xc0dfb
movq %r14, %rdi
callq 0x152db
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc0eb2
movl $0x1e0181, %eax         # imm = 0x1E0181
btq %rdx, %rax
jb 0xc0eb2
cmpl $0x13, %edx
je 0xc0ed3
movl %edx, %eax
leaq 0x327be(%rip), %rcx     # 0xf3640
movl (%rcx,%rax,4), %eax
shlq $0x5, %rax
leaq 0x6e8e0(%rip), %r14     # 0x12f770
addq %rax, %r14
leaq 0x32916(%rip), %rdx     # 0xf37b0
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
movl $0x30b, %ecx            # imm = 0x30B
callq 0xce9a
movq %rax, %rbx
movq %r14, (%rax)
jmp 0xc0ec8
leaq 0x33462(%rip), %rax     # 0xf431b
xorl %ebx, %ebx
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0xc007
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x6d0de(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x9182(%rip), %rsi      # 0xca066
leaq 0x3345e(%rip), %rdx     # 0xf4349
leaq 0x33474(%rip), %rcx     # 0xf4366
leaq 0x328b7(%rip), %r8      # 0xf37b0
movl $0xd4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc0fcd
movq %r8, %rbx
testq %r8, %r8
je 0xc0fcd
movq %r9, %r14
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
testq %r9, %r9
je 0xc0f92
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0xc0ffb
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 0xc1033
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
movq 0x6cfe4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x9088(%rip), %rsi      # 0xca066
leaq 0x327fd(%rip), %rdx     # 0xf37e2
leaq 0x32802(%rip), %rcx     # 0xf37ee
leaq 0x327bd(%rip), %r8      # 0xf37b0
movl $0x31f, %r9d            # imm = 0x31F
jmp 0xc1027
movq 0x6cfb6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x905a(%rip), %rsi      # 0xca066
leaq 0x9646(%rip), %rdx      # 0xca659
leaq 0x327d4(%rip), %rcx     # 0xf37ee
leaq 0x3278f(%rip), %r8      # 0xf37b0
movl $0x320, %r9d            # imm = 0x320
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
andl $0x0, 0x4(%rsp)
testq %rdi, %rdi
je 0xc1205
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 0xc1033
movq (%rbx), %rax
movq 0x18(%rax), %rax
movl (%r14), %ecx
cmpb $0x4d, (%rax,%rcx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x6cdac(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x8e50(%rip), %rsi      # 0xca066
leaq 0x23256(%rip), %rdx     # 0xe4473
leaq 0x325e9(%rip), %rcx     # 0xf380d
leaq 0x32585(%rip), %r8      # 0xf37b0
movl $0x330, %r9d            # imm = 0x330
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc1266
movq (%rdi), %rax
movq 0x10(%rax), %rdi
movzbl %sil, %esi
movzbl %dl, %edx
movzbl %cl, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xc1033
cmpb $0x2a, %al
sete %al
popq %rcx
retq
movq 0x6cd4b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x8def(%rip), %rsi      # 0xca066
leaq 0x231f5(%rip), %rdx     # 0xe4473
leaq 0x325a6(%rip), %rcx     # 0xf382b
leaq 0x32524(%rip), %r8      # 0xf37b0
movl $0x340, %r9d            # imm = 0x340
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x13da9
movq %rax, %r13
movzbl %r12b, %r9d
movq %r15, %rdi
movl %r14d, %esi
movq %rax, %rdx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0xc1838
movq %rax, %rbx
movq %r13, %rdi
callq 0x152db
movq (%rsp), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x296d9
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x4f21f
cmpq $0x0, 0x6e67e(%rip)     # 0x12fd88
jne 0xc1736
andq $0x0, (%rsp)
leaq 0x2c(%rip), %rsi        # 0xc1744
leaq 0x93(%rip), %rcx        # 0xc17b2
pushq $0x40
popq %rdi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x25f10
movq %rax, 0x6e652(%rip)     # 0x12fd88
callq 0x4f266
movq 0x6e646(%rip), %rax     # 0x12fd88
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc16fc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2603e
testq %rax, %rax
je 0xc177c
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x152db
movq 0x20(%rbx), %rdi
callq 0xc4ced
movq 0x28(%rbx), %rdi
popq %rbx
jmp 0x88de2
movq 0x6c835(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x88d9(%rip), %rsi      # 0xca066
leaq 0x32c5c(%rip), %rdx     # 0xf43f0
leaq 0x32c61(%rip), %rcx     # 0xf43fc
leaq 0x32c33(%rip), %r8      # 0xf43d5
pushq $0x32
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc16fc
movq %rax, %rdi
movq %r15, %rsi
callq 0x2603e
movq %rax, %r15
testq %rbx, %rbx
je 0xc17e4
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0xc1800
leaq 0x139(%rip), %rdx       # 0xc1924
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x19e82
movq 0x6c7b1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x8855(%rip), %rsi      # 0xca066
leaq 0x8e41(%rip), %rdx      # 0xca659
leaq 0x32bee(%rip), %rcx     # 0xf440d
leaq 0x32baf(%rip), %r8      # 0xf43d5
movl $0x12d, %r9d            # imm = 0x12D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc16fc
movq %rax, %rdi
callq 0x25fe0
movq %rax, %rbx
callq 0xc16fc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2603e
movq %rax, %rbp
movl %r13d, 0x10(%rax)
movq %r12, %rdi
callq 0x146aa
movq %rax, 0x18(%rbp)
callq 0xc4648
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_O2/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 0x4f21f
cmpq $0x0, 0x6d9da(%rip)     # 0x12fd90
jne 0xc23d5
leaq 0x24(%rip), %rsi        # 0xc23e3
leaq 0x47(%rip), %rdx        # 0xc240d
pushq $0x20
popq %rdi
callq 0x25a78
movq %rax, 0x6d9bb(%rip)     # 0x12fd90
callq 0x4f266
movq 0x6d9af(%rip), %rax     # 0x12fd90
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc2430
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0xc24b1
callq 0xc23a8
movq %rax, %rdi
movq %r15, %rsi
callq 0x25ec1
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0xc28f5
testq %rax, %rax
jne 0xc249d
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x25c62
testl %eax, %eax
jne 0xc24ab
movq (%rbx), %rdi
movq 0x18(%r15), %rsi
testq %rdi, %rdi
je 0xc2482
movq %r14, %rdx
callq 0x1c56c
testl %eax, %eax
jne 0xc24ab
movq 0x18(%r15), %rdi
jmp 0xc2447
pushq $0x1
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0xc2931
movq 0x18(%r15), %rdi
callq 0xc28f5
testq %rax, %rax
je 0xc24a9
movq 0x18(%r15), %rdi
callq 0xc2913
movq %rax, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x6bb00(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x7ba4(%rip), %rsi      # 0xca066
leaq 0x8190(%rip), %rdx      # 0xca659
leaq 0x3207a(%rip), %rcx     # 0xf454a
leaq 0x32083(%rip), %r8      # 0xf455a
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xc23a8
movq %rax, %r15
movq %r14, %rdi
callq 0x25e7d
movzbl %al, %esi
movq %r15, %rdi
callq 0x25adf
movq %rax, %r15
callq 0xc23a8
movq %rax, %rdi
movq %r15, %rsi
callq 0x25ec1
movq %rax, %r12
movq %r14, %rdi
callq 0x25b74
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0xc2893
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop