LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: store_predicted_exon
static void store_predicted_exon(GtTranscriptEvaluators *te, GtFeatureNode *fn)
{
  gt_assert(te && fn);
  gt_evaluator_add_predicted(gt_transcript_evaluators_get_all(te), 1);
  switch (gt_feature_node_get_transcriptfeaturetype(fn)) {
    case TRANSCRIPT_FEATURE_TYPE_UNDETERMINED:
      gt_warning("type of feature (single, initial, internal, or terminal) "
                 "given on line %u in file \"%s\" could not be determined, "
                 "because the feature has no Parent attribute. Treating it as "
                 "single.",
                 gt_genome_node_get_line_number((GtGenomeNode*) fn),
                 gt_genome_node_get_filename((GtGenomeNode*) fn));
      /*@fallthrough@*/
    case TRANSCRIPT_FEATURE_TYPE_SINGLE:
      gt_evaluator_add_predicted(gt_transcript_evaluators_get_single(te), 1);
    break;
    case TRANSCRIPT_FEATURE_TYPE_INITIAL:
      gt_evaluator_add_predicted(gt_transcript_evaluators_get_initial(te), 1);
    break;
    case TRANSCRIPT_FEATURE_TYPE_INTERNAL:
      gt_evaluator_add_predicted(gt_transcript_evaluators_get_internal(te), 1);
    break;
    case TRANSCRIPT_FEATURE_TYPE_TERMINAL:
      gt_evaluator_add_predicted(gt_transcript_evaluators_get_terminal(te), 1);
    break;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8de55
movq %rsi, %r14
testq %rsi, %rsi
je 0x8de55
movq %rdi, %rbx
callq 0x8eddf
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xc37d7
movq %r14, %rdi
callq 0x1a3f7
cmpl $0x4, %eax
ja 0x8de50
movl %eax, %eax
leaq 0x575e7(%rip), %rcx     # 0xe53d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x8ee60
jmp 0x8de41
movq %r14, %rdi
callq 0x1c2d8
movl %eax, %ebp
movq %r14, %rdi
callq 0x1c285
leaq 0x5798e(%rip), %rdi     # 0xe57a7
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x161b0
movq %rbx, %rdi
callq 0x8ee1f
jmp 0x8de41
movq %rbx, %rdi
callq 0x8eea1
jmp 0x8de41
movq %rbx, %rdi
callq 0x8eee2
pushq $0x1
popq %rsi
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc37d7
popq %rbx
popq %r14
popq %rbp
retq
movq 0xa015c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3c200(%rip), %rsi     # 0xca066
leaq 0x57d98(%rip), %rdx     # 0xe5c05
leaq 0x57d9a(%rip), %rcx     # 0xe5c0e
leaq 0x57595(%rip), %r8      # 0xe5410
movl $0x2c7, %r9d            # imm = 0x2C7
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: store_predicted_exon_collapsed
static void store_predicted_exon_collapsed(GtTranscriptUsedExons *used_exons,
                                           GtRange *predicted_range,
                                           GtTranscriptEvaluators *te,
                                           GtFeatureNode *fn)
{
  add_predicted_collapsed(gt_transcript_used_exons_get_all(used_exons),
                          predicted_range,
                          gt_transcript_evaluators_get_all(te));
  switch (gt_feature_node_get_transcriptfeaturetype(fn)) {
    case TRANSCRIPT_FEATURE_TYPE_UNDETERMINED:
      /* we do not show a warning here, because store_predicted_exon() has been
         called before and already shown one */
    case TRANSCRIPT_FEATURE_TYPE_SINGLE:
      add_predicted_collapsed(gt_transcript_used_exons_get_single(used_exons),
                              predicted_range,
                              gt_transcript_evaluators_get_single(te));
      break;
    case TRANSCRIPT_FEATURE_TYPE_INITIAL:
      add_predicted_collapsed(gt_transcript_used_exons_get_initial(used_exons),
                              predicted_range,
                              gt_transcript_evaluators_get_initial(te));
      break;
    case TRANSCRIPT_FEATURE_TYPE_INTERNAL:
      add_predicted_collapsed(gt_transcript_used_exons_get_internal(used_exons),
                              predicted_range,
                              gt_transcript_evaluators_get_internal(te));
      break;
    case TRANSCRIPT_FEATURE_TYPE_TERMINAL:
      add_predicted_collapsed(gt_transcript_used_exons_get_terminal(used_exons),
                              predicted_range,
                              gt_transcript_evaluators_get_terminal(te));
      break;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x8f4fa
movq %rax, %r13
movq %r14, %rdi
callq 0x8eddf
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x8e4bc
movq %r12, %rdi
callq 0x1a3f7
cmpl $0x4, %eax
ja 0x8df48
movl %eax, %eax
leaq 0x57512(%rip), %rcx     # 0xe53e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rdi
callq 0x8f53a
movq %rax, %r15
movq %r14, %rdi
callq 0x8ee1f
jmp 0x8df31
movq %r15, %rdi
callq 0x8f5fd
movq %rax, %r15
movq %r14, %rdi
callq 0x8eee2
jmp 0x8df31
movq %r15, %rdi
callq 0x8f57b
movq %rax, %r15
movq %r14, %rdi
callq 0x8ee60
jmp 0x8df31
movq %r15, %rdi
callq 0x8f5bc
movq %rax, %r15
movq %r14, %rdi
callq 0x8eea1
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8e4bc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: store_gene_feature
static int store_gene_feature(GtFeatureNode *fn, void *data,
                              GT_UNUSED GtError *err)
{
  StoreGeneFeatureInfo *info = (StoreGeneFeatureInfo*) data;
  GtRange range;
  gt_error_check(err);
  gt_assert(fn && info);
  if (gt_feature_node_has_type(fn, gt_ft_mRNA))
    gt_array_add(info->mRNAs, fn);
  else if (gt_feature_node_has_type(fn, info->feature_type)) {
    range = gt_genome_node_get_range((GtGenomeNode*) fn);
    gt_array_add(info->exons, range);
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, (%rsp)
testq %rdx, %rdx
je 0x8e32e
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x8e3bd
testq %rbx, %rbx
je 0x8e38f
testq %r14, %r14
je 0x8e38f
leaq 0x3f8eb(%rip), %rsi     # 0xcdc2a
movq %r14, %rdi
callq 0x1987b
testb %al, %al
je 0x8e356
movq 0x8(%rbx), %rdi
movq %rsp, %rsi
pushq $0x8
jmp 0x8e37f
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1987b
testb %al, %al
je 0x8e385
movq %r14, %rdi
callq 0x1c3c4
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq (%rbx), %rdi
pushq $0x10
popq %rdx
callq 0x4b801
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x9fc22(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3bcc6(%rip), %rsi     # 0xca066
leaq 0x403c8(%rip), %rdx     # 0xce76f
leaq 0x57829(%rip), %rcx     # 0xe5bd7
leaq 0x5705b(%rip), %r8      # 0xe5410
movl $0x27c, %r9d            # imm = 0x27C
jmp 0x8e3e9
movq 0x9fbf4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3bc98(%rip), %rsi     # 0xca066
leaq 0x3c284(%rip), %rdx     # 0xca659
leaq 0x577fb(%rip), %rcx     # 0xe5bd7
leaq 0x5702d(%rip), %r8      # 0xe5410
movl $0x27b, %r9d            # imm = 0x27B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: store_exon
static int store_exon(GtFeatureNode *fn, void *data, GT_UNUSED GtError *err)
{
  StoreExonFeatureInfo *info = (StoreExonFeatureInfo*) data;
  GtRange range;
  gt_error_check(err);
  gt_assert(fn && info);
  if (gt_feature_node_has_type(fn, info->feature_type)) {
    range = gt_genome_node_get_range((GtGenomeNode*) fn);
    gt_array_add(info->exons, range);
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x8e413
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x8e484
testq %r14, %r14
je 0x8e456
testq %rbx, %rbx
je 0x8e456
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1987b
testb %al, %al
je 0x8e44c
movq %r14, %rdi
callq 0x1c3c4
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq (%rbx), %rdi
pushq $0x10
popq %rdx
callq 0x4b801
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x9fb5b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3bbff(%rip), %rsi     # 0xca066
leaq 0x40301(%rip), %rdx     # 0xce76f
leaq 0x57785(%rip), %rcx     # 0xe5bfa
leaq 0x56f94(%rip), %r8      # 0xe5410
movl $0x241, %r9d            # imm = 0x241
jmp 0x8e4b0
movq 0x9fb2d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3bbd1(%rip), %rsi     # 0xca066
leaq 0x3c1bd(%rip), %rdx     # 0xca659
leaq 0x57757(%rip), %rcx     # 0xe5bfa
leaq 0x56f66(%rip), %r8      # 0xe5410
movl $0x240, %r9d            # imm = 0x240
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: add_predicted_collapsed
static void add_predicted_collapsed(GtDlist *used_exons,
                                    GtRange *predicted_range,
                                    GtEvaluator *exon_evaluator_collapsed)
{
  GtRange *used_range;
  if (!gt_dlist_find(used_exons, predicted_range)) {
    used_range = gt_malloc(sizeof (GtRange));
    used_range->start = predicted_range->start;
    used_range->end = predicted_range->end;
    gt_dlist_add(used_exons, used_range);
    gt_evaluator_add_predicted(exon_evaluator_collapsed, 1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x50662
testq %rax, %rax
je 0x8e4da
popq %rbx
popq %r14
popq %r15
retq
leaq 0x56f2f(%rip), %rsi     # 0xe5410
pushq $0x10
popq %rdi
movl $0x2e8, %edx            # imm = 0x2E8
callq 0xccb0
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x5077a
pushq $0x1
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xc37d7
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: mark_and_show_false_exon
static void mark_and_show_false_exon(GtFeatureNode *fn, bool exondiff)
{
  gt_feature_node_mark(fn); /* mark false exons */
  if (exondiff) {
    gt_gff3_output_leading(fn, NULL);
    printf(".\n");
  }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1b1a9
testl %ebp, %ebp
je 0x8e718
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6568c
leaq 0x44cf1(%rip), %rdi     # 0xd33fe
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb9b0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: add_nucleotide_values
static void add_nucleotide_values(NucEval *nucleotides, GtBittab *real,
                                  GtBittab *pred, GtBittab *tmp,
                                  const char *level)
{
  gt_assert(nucleotides && real && pred && tmp);
  if (gt_log_enabled()) {
    gt_log_log("%s", level);
    gt_log_log("reference:");
    gt_bittab_show(real, gt_log_fp());
    gt_log_log("prediction:");
    gt_bittab_show(pred, gt_log_fp());
  }
  /* real & pred = TP */
  gt_bittab_and(tmp, real, pred);
  nucleotides->TP += gt_bittab_count_set_bits(tmp);
  /* ~real & pred = FP */;
  gt_bittab_complement(tmp, real);
  gt_bittab_and_equal(tmp, pred);
  nucleotides->FP += gt_bittab_count_set_bits(tmp);
  /* real & ~pred = FN */
  gt_bittab_complement(tmp, pred);
  gt_bittab_and_equal(tmp, real);
  nucleotides->FN += gt_bittab_count_set_bits(tmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0x8e836
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0xc5c6
testb %al, %al
je 0x8e7cf
leaq 0x49320(%rip), %rdi     # 0xd7aa9
movq %r13, %rsi
xorl %eax, %eax
callq 0xc5d2
leaq 0x57572(%rip), %rdi     # 0xe5d0c
xorl %eax, %eax
callq 0xc5d2
callq 0xc679
movq %r15, %rdi
movq %rax, %rsi
callq 0x4e178
leaq 0x5755f(%rip), %rdi     # 0xe5d17
xorl %eax, %eax
callq 0xc5d2
callq 0xc679
movq %r12, %rdi
movq %rax, %rsi
callq 0x4e178
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4d8db
movq %r14, %rdi
callq 0x4e0f8
addq %rax, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4d7e3
movq %r14, %rdi
movq %r12, %rsi
callq 0x4db48
movq %r14, %rdi
callq 0x4e0f8
addq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x4d7e3
movq %r14, %rdi
movq %r15, %rsi
callq 0x4db48
movq %r14, %rdi
callq 0x4e0f8
addq %rax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x9f77b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3b81f(%rip), %rsi     # 0xca066
leaq 0x57485(%rip), %rdx     # 0xe5cd3
leaq 0x574a1(%rip), %rcx     # 0xe5cf6
leaq 0x56bb4(%rip), %r8      # 0xe5410
movl $0x509, %r9d            # imm = 0x509
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_bittabs.c
// Function: gt_transcript_bittabs_new
GtTranscriptBittabs* gt_transcript_bittabs_new(GtUword size_all,
                                               GtUword size_single,
                                               GtUword size_initial,
                                               GtUword size_internal,
                                               GtUword size_terminal)
{
  GtTranscriptBittabs *tb = gt_calloc(1, sizeof (GtTranscriptBittabs));
  if (size_all) tb->gt_bittab_all = gt_bittab_new(size_all);
  if (size_single) tb->gt_bittab_single = gt_bittab_new(size_single);
  if (size_initial) tb->gt_bittab_initial = gt_bittab_new(size_initial);
  if (size_internal) tb->gt_bittab_internal = gt_bittab_new(size_internal);
  if (size_terminal) tb->gt_bittab_terminal = gt_bittab_new(size_all);
  return tb;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x576f7(%rip), %rdx     # 0xe5f88
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
pushq $0x23
popq %rcx
callq 0xce9a
movq %rax, %r15
testq %rbx, %rbx
je 0x8e8b2
movq %rbx, %rdi
callq 0x4d6a4
movq %rax, (%r15)
testq %rbp, %rbp
je 0x8e8c3
movq %rbp, %rdi
callq 0x4d6a4
movq %rax, 0x8(%r15)
testq %r13, %r13
je 0x8e8d4
movq %r13, %rdi
callq 0x4d6a4
movq %rax, 0x10(%r15)
testq %r12, %r12
je 0x8e8e5
movq %r12, %rdi
callq 0x4d6a4
movq %rax, 0x18(%r15)
testq %r14, %r14
je 0x8e8f6
movq %rbx, %rdi
callq 0x4d6a4
movq %rax, 0x20(%r15)
movq %r15, %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/transcript_bittabs.c
// Function: gt_transcript_bittabs_delete
void gt_transcript_bittabs_delete(GtTranscriptBittabs *tb)
{
  if (!tb) return;
  gt_bittab_delete(tb->gt_bittab_all);
  gt_bittab_delete(tb->gt_bittab_single);
  gt_bittab_delete(tb->gt_bittab_initial);
  gt_bittab_delete(tb->gt_bittab_internal);
  gt_bittab_delete(tb->gt_bittab_terminal);
  gt_free(tb);
}

// Assembly:
testq %rdi, %rdi
je 0x8ea94
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4e2ea
movq 0x8(%rbx), %rdi
callq 0x4e2ea
movq 0x10(%rbx), %rdi
callq 0x4e2ea
movq 0x18(%rbx), %rdi
callq 0x4e2ea
movq 0x20(%rbx), %rdi
callq 0x4e2ea
leaq 0x57500(%rip), %rsi     # 0xe5f88
pushq $0x52
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_counts.c
// Function: gt_transcript_counts_delete
void gt_transcript_counts_delete(GtTranscriptCounts *tc)
{
  if (!tc) return;
  gt_array_delete(tc->exon_array_all);
  gt_array_delete(tc->exon_array_single);
  gt_array_delete(tc->exon_array_initial);
  gt_array_delete(tc->exon_array_internal);
  gt_array_delete(tc->exon_array_terminal);
  gt_free(tc);
}

// Assembly:
testq %rdi, %rdi
je 0x8ed96
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4c19d
movq 0x8(%rbx), %rdi
callq 0x4c19d
movq 0x10(%rbx), %rdi
callq 0x4c19d
movq 0x18(%rbx), %rdi
callq 0x4c19d
movq 0x20(%rbx), %rdi
callq 0x4c19d
leaq 0x572ca(%rip), %rsi     # 0xe6054
pushq $0x67
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_evaluators.c
// Function: gt_transcript_evaluators_new
GtTranscriptEvaluators* gt_transcript_evaluators_new(void)
{
  GtTranscriptEvaluators *te = gt_malloc(sizeof (GtTranscriptEvaluators));
  te->exon_evaluator_all = gt_evaluator_new();
  te->exon_evaluator_single = gt_evaluator_new();
  te->exon_evaluator_initial = gt_evaluator_new();
  te->exon_evaluator_internal = gt_evaluator_new();
  te->exon_evaluator_terminal = gt_evaluator_new();
  return te;
}

// Assembly:
pushq %rbx
leaq 0x57426(%rip), %rsi     # 0xe61c6
pushq $0x28
popq %rdi
pushq $0x1f
popq %rdx
callq 0xccb0
movq %rax, %rbx
callq 0xc3704
movq %rax, (%rbx)
callq 0xc3704
movq %rax, 0x8(%rbx)
callq 0xc3704
movq %rax, 0x10(%rbx)
callq 0xc3704
movq %rax, 0x18(%rbx)
callq 0xc3704
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_evaluators.c
// Function: gt_transcript_evaluators_add_actuals
void gt_transcript_evaluators_add_actuals(const GtTranscriptEvaluators
                                                                *evaluators,
                                          const GtTranscriptExons *exons)
{
  gt_assert(evaluators && exons);
  gt_evaluator_add_actual(evaluators->exon_evaluator_all,
                       gt_array_size(gt_transcript_exons_get_all(exons)));
  gt_evaluator_add_actual(evaluators->exon_evaluator_single,
                       gt_array_size(gt_transcript_exons_get_single(exons)));
  gt_evaluator_add_actual(evaluators->exon_evaluator_initial,
                       gt_array_size(gt_transcript_exons_get_initial(exons)));
  gt_evaluator_add_actual(evaluators->exon_evaluator_internal,
                       gt_array_size(gt_transcript_exons_get_internal(exons)));
  gt_evaluator_add_actual(evaluators->exon_evaluator_terminal,
                       gt_array_size(gt_transcript_exons_get_terminal(exons)));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8efdf
movq %rsi, %rbx
testq %rsi, %rsi
je 0x8efdf
movq %rdi, %r14
movq (%rdi), %r15
movq %rbx, %rdi
callq 0x8f0c3
movq %rax, %rdi
callq 0x4b988
movq %r15, %rdi
movq %rax, %rsi
callq 0xc3796
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0x8f103
movq %rax, %rdi
callq 0x4b988
movq %r15, %rdi
movq %rax, %rsi
callq 0xc3796
movq 0x10(%r14), %r15
movq %rbx, %rdi
callq 0x8f144
movq %rax, %rdi
callq 0x4b988
movq %r15, %rdi
movq %rax, %rsi
callq 0xc3796
movq 0x18(%r14), %r15
movq %rbx, %rdi
callq 0x8f185
movq %rax, %rdi
callq 0x4b988
movq %r15, %rdi
movq %rax, %rsi
callq 0xc3796
movq 0x20(%r14), %r14
movq %rbx, %rdi
callq 0x8f1c6
movq %rax, %rdi
callq 0x4b988
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xc3796
movq 0x9efd2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3b076(%rip), %rsi     # 0xca066
leaq 0x572aa(%rip), %rdx     # 0xe62a1
leaq 0x572b7(%rip), %rcx     # 0xe62b5
leaq 0x571c1(%rip), %r8      # 0xe61c6
pushq $0x4e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_evaluators.c
// Function: gt_transcript_evaluators_delete
void gt_transcript_evaluators_delete(GtTranscriptEvaluators *te)
{
  if (!te) return;
  gt_evaluator_delete(te->exon_evaluator_all);
  gt_evaluator_delete(te->exon_evaluator_single);
  gt_evaluator_delete(te->exon_evaluator_initial);
  gt_evaluator_delete(te->exon_evaluator_internal);
  gt_evaluator_delete(te->exon_evaluator_terminal);
  gt_free(te);
}

// Assembly:
testq %rdi, %rdi
je 0x8f05d
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xc4420
movq 0x8(%rbx), %rdi
callq 0xc4420
movq 0x10(%rbx), %rdi
callq 0xc4420
movq 0x18(%rbx), %rdi
callq 0xc4420
movq 0x20(%rbx), %rdi
callq 0xc4420
leaq 0x57175(%rip), %rsi     # 0xe61c6
pushq $0x63
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_exons.c
// Function: gt_transcript_exons_new
GtTranscriptExons* gt_transcript_exons_new(void)
{
  GtTranscriptExons *te = gt_malloc(sizeof (GtTranscriptExons));
  te->exon_array_all = gt_array_new(sizeof (GtRange));
  te->exon_array_single = gt_array_new(sizeof (GtRange));
  te->exon_array_initial = gt_array_new(sizeof (GtRange));
  te->exon_array_internal = gt_array_new(sizeof (GtRange));
  te->exon_array_terminal = gt_array_new(sizeof (GtRange));
  return te;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5726f(%rip), %rsi     # 0xe62da
pushq $0x28
popq %rdi
pushq $0x20
popq %rdx
callq 0xccb0
movq %rax, %rbx
pushq $0x10
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x4b380
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x4b380
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x4b380
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x4b380
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_exons.c
// Function: gt_transcript_exons_sort
void gt_transcript_exons_sort(const GtTranscriptExons *te)
{
  gt_assert(te);
  gt_ranges_sort(te->exon_array_all);
  gt_ranges_sort(te->exon_array_single);
  gt_ranges_sort(te->exon_array_initial);
  gt_ranges_sort(te->exon_array_internal);
  gt_ranges_sort(te->exon_array_terminal);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x8f23d
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5db48
movq 0x8(%rbx), %rdi
callq 0x5db48
movq 0x10(%rbx), %rdi
callq 0x5db48
movq 0x18(%rbx), %rdi
callq 0x5db48
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x5db48
movq 0x9ed74(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3ae18(%rip), %rsi     # 0xca066
leaq 0x40d90(%rip), %rdx     # 0xcffe5
leaq 0x5713b(%rip), %rcx     # 0xe6397
leaq 0x57077(%rip), %r8      # 0xe62da
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_exons.c
// Function: gt_transcript_exons_uniq_in_place_count
GtTranscriptCounts* gt_transcript_exons_uniq_in_place_count(GtTranscriptExons
                                                                         *te)
{
  GtTranscriptCounts *tc;
  GtArray *counts;
  gt_assert(te);
  tc = gt_transcript_counts_new();
  counts = gt_ranges_uniq_in_place_count(te->exon_array_all);
  gt_transcript_counts_set_all(tc, counts);
  counts = gt_ranges_uniq_in_place_count(te->exon_array_single);
  gt_transcript_counts_set_single(tc, counts);
  counts = gt_ranges_uniq_in_place_count(te->exon_array_initial);
  gt_transcript_counts_set_initial(tc, counts);
  counts = gt_ranges_uniq_in_place_count(te->exon_array_internal);
  gt_transcript_counts_set_internal(tc, counts);
  counts = gt_ranges_uniq_in_place_count(te->exon_array_terminal);
  gt_transcript_counts_set_terminal(tc, counts);
  return tc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8f2f5
movq %rdi, %r14
callq 0x8ea98
movq %rax, %rbx
movq (%r14), %rdi
callq 0x5db02
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8eaed
movq 0x8(%r14), %rdi
callq 0x5db02
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8eb73
movq 0x10(%r14), %rdi
callq 0x5db02
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8ebfa
movq 0x18(%r14), %rdi
callq 0x5db02
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8ec81
movq 0x20(%r14), %rdi
callq 0x5db02
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8ed08
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9ecbc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3ad60(%rip), %rsi     # 0xca066
leaq 0x40cd8(%rip), %rdx     # 0xcffe5
leaq 0x5709c(%rip), %rcx     # 0xe63b0
leaq 0x56fbf(%rip), %r8      # 0xe62da
pushq $0x56
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_exons.c
// Function: gt_transcript_exons_are_sorted
bool gt_transcript_exons_are_sorted(const GtTranscriptExons *te)
{
  gt_assert(te);
  if (!gt_ranges_are_sorted(te->exon_array_all)) return false;
  if (!gt_ranges_are_sorted(te->exon_array_single)) return false;
  if (!gt_ranges_are_sorted(te->exon_array_initial)) return false;
  if (!gt_ranges_are_sorted(te->exon_array_internal)) return false;
  if (!gt_ranges_are_sorted(te->exon_array_terminal)) return false;
  return true;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x8f375
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5dc28
testb %al, %al
je 0x8f371
movq 0x8(%rbx), %rdi
callq 0x5dc28
testb %al, %al
je 0x8f371
movq 0x10(%rbx), %rdi
callq 0x5dc28
testb %al, %al
je 0x8f371
movq 0x18(%rbx), %rdi
callq 0x5dc28
testb %al, %al
je 0x8f371
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x5dc28
xorl %eax, %eax
popq %rbx
retq
movq 0x9ec3c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3ace0(%rip), %rsi     # 0xca066
leaq 0x40c58(%rip), %rdx     # 0xcffe5
leaq 0x57044(%rip), %rcx     # 0xe63d8
leaq 0x56f3f(%rip), %r8      # 0xe62da
pushq $0x67
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_exons.c
// Function: gt_transcript_exons_create_bittabs
GtTranscriptBittabs* gt_transcript_exons_create_bittabs(const
                                                        GtTranscriptExons *te)
{
  gt_assert(te);
  return gt_transcript_bittabs_new(gt_array_size(te->exon_array_all),
                                   gt_array_size(te->exon_array_single),
                                   gt_array_size(te->exon_array_initial),
                                   gt_array_size(te->exon_array_internal),
                                   gt_array_size(te->exon_array_terminal));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x8f411
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4b988
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x4b988
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x4b988
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x4b988
movq %rax, %r13
movq 0x20(%rbx), %rdi
callq 0x4b988
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rax, %r8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8e870
movq 0x9eba0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3ac44(%rip), %rsi     # 0xca066
leaq 0x40bbc(%rip), %rdx     # 0xcffe5
leaq 0x56fc7(%rip), %rcx     # 0xe63f7
leaq 0x56ea3(%rip), %r8      # 0xe62da
pushq $0x73
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_exons.c
// Function: gt_transcript_exons_delete
void gt_transcript_exons_delete(GtTranscriptExons *te)
{
  if (!te) return;
  gt_array_delete(te->exon_array_all);
  gt_array_delete(te->exon_array_single);
  gt_array_delete(te->exon_array_initial);
  gt_array_delete(te->exon_array_internal);
  gt_array_delete(te->exon_array_terminal);
  gt_free(te);
}

// Assembly:
testq %rdi, %rdi
je 0x8f491
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4c19d
movq 0x8(%rbx), %rdi
callq 0x4c19d
movq 0x10(%rbx), %rdi
callq 0x4c19d
movq 0x18(%rbx), %rdi
callq 0x4c19d
movq 0x20(%rbx), %rdi
callq 0x4c19d
leaq 0x56e57(%rip), %rsi     # 0xe62da
movq %rbx, %rdi
movl $0x83, %edx
popq %rbx
jmp 0xd249
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_used_exons.c
// Function: gt_transcript_used_exons_new
GtTranscriptUsedExons* gt_transcript_used_exons_new(void)
{
  GtTranscriptUsedExons *tue = gt_malloc(sizeof (GtTranscriptUsedExons));
  tue->used_exons_all = gt_dlist_new((GtCompare) gt_range_compare);
  tue->used_exons_single = gt_dlist_new((GtCompare) gt_range_compare);
  tue->used_exons_initial = gt_dlist_new((GtCompare) gt_range_compare);
  tue->used_exons_internal = gt_dlist_new((GtCompare) gt_range_compare);
  tue->used_exons_terminal = gt_dlist_new((GtCompare) gt_range_compare);
  return tue;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x56f7b(%rip), %rsi     # 0xe641a
pushq $0x28
popq %rdi
pushq $0x20
popq %rdx
callq 0xccb0
movq %rax, %rbx
leaq -0x325ec(%rip), %r14    # 0x5cec8
movq %r14, %rdi
callq 0x50580
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x50580
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x50580
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x50580
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x50580
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_used_exons.c
// Function: gt_transcript_used_exons_delete
void gt_transcript_used_exons_delete(GtTranscriptUsedExons *tue)
{
  if (!tue) return;
  used_gt_dlist_delete(tue->used_exons_all);
  used_gt_dlist_delete(tue->used_exons_single);
  used_gt_dlist_delete(tue->used_exons_initial);
  used_gt_dlist_delete(tue->used_exons_internal);
  used_gt_dlist_delete(tue->used_exons_terminal);
  gt_free(tue);
}

// Assembly:
testq %rdi, %rdi
je 0x8f686
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8f687
movq 0x8(%rbx), %rdi
callq 0x8f687
movq 0x10(%rbx), %rdi
callq 0x8f687
movq 0x18(%rbx), %rdi
callq 0x8f687
movq 0x20(%rbx), %rdi
callq 0x8f687
leaq 0x56da0(%rip), %rsi     # 0xe641a
pushq $0x59
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/transcript_used_exons.c
// Function: used_gt_dlist_delete
static void used_gt_dlist_delete(GtDlist *used_list)
{
  GtDlistelem *dlistelem;
  for (dlistelem = gt_dlist_first(used_list); dlistelem != NULL;
       dlistelem = gt_dlistelem_next(dlistelem)) {
    gt_free(gt_dlistelem_get_data(dlistelem));
  }
  gt_dlist_delete(used_list);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x505e0
movq %rax, %r15
leaq 0x56d7a(%rip), %r14     # 0xe641a
pushq $0x4c
popq %rbp
testq %r15, %r15
je 0x8f6ca
movq %r15, %rdi
callq 0x506e7
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xd249
movq %r15, %rdi
callq 0x5072a
movq %rax, %r15
jmp 0x8f6a3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x50c04
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/alphabet_lua.c
// Function: gt_lua_open_alphabet
int gt_lua_open_alphabet(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, ALPHABET_METATABLE);
  /* metatable.__index = metatable */
  lua_pushvalue(L, -1); /* duplicate the metatable */
  lua_setfield(L, -2, "__index");
  /* set its _gc field */
  lua_pushstring(L, "__gc");
  lua_pushcfunction(L, alphabet_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, alphabet_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", alphabet_lib_f);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8f79f
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x4f879(%rip), %rsi     # 0xdef73
movq %rbx, %rdi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x47b6a(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f41
leaq 0x474a8(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xcc(%rip), %rsi        # 0x8f805
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0x9d8bb(%rip), %rdx     # 0x12d010
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
leaq 0x5ab06(%rip), %rsi     # 0xea277
leaq 0x9d8e8(%rip), %rdx     # 0x12d060
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x8f7cd
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x9e812(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a8b6(%rip), %rsi     # 0xca066
leaq 0x4723f(%rip), %rdx     # 0xd69f6
leaq 0x56d3b(%rip), %rcx     # 0xe64f9
leaq 0x56d49(%rip), %r8      # 0xe650e
movl $0x8b, %r9d
jmp 0x8f7f9
movq 0x9e7e4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a888(%rip), %rsi     # 0xca066
leaq 0x4e5f6(%rip), %rdx     # 0xddddb
leaq 0x56d0d(%rip), %rcx     # 0xe64f9
leaq 0x56d1b(%rip), %r8      # 0xe650e
movl $0x9c, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/alphabet_lua.c
// Function: gt_lua_alphabet_push
void gt_lua_alphabet_push(lua_State *L, GtAlphabet *alpha)
{
  GtAlphabet **alphaptr;
  gt_assert(L && alpha);
  alphaptr = lua_newuserdata(L, sizeof (*alphaptr));
  *alphaptr = alpha;
  luaL_getmetatable(L, ALPHABET_METATABLE);
  lua_setmetatable(L, -2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8f866
movq %rsi, %r14
testq %rsi, %rsi
je 0x8f866
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x39c01
movq %r14, (%rax)
leaq 0x4f72c(%rip), %rdx     # 0xdef73
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3914f
movq 0x9e74b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a7ef(%rip), %rsi     # 0xca066
leaq 0x56ca9(%rip), %rdx     # 0xe6527
leaq 0x56cad(%rip), %rcx     # 0xe6532
leaq 0x56c82(%rip), %r8      # 0xe650e
movl $0xa3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/alphabet_lua.c
// Function: alphabet_lua_add_mapping
static int alphabet_lua_add_mapping(lua_State *L)
{
  GtAlphabet **alpha;
  const char *characters;
  alpha = check_alphabet(L, 1);
  characters = luaL_checkstring(L, 2);
  luaL_argcheck(L, strlen(characters), 2,
                "mapping must contain at least one character");
  gt_alphabet_add_mapping(*alpha, characters);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4f6c6(%rip), %rdx     # 0xdef73
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x8f8df
leaq 0x56c73(%rip), %rdx     # 0xe6547
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq %r15, %rsi
callq 0x9ae92
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/alphabet_lua.c
// Function: alphabet_lua_add_wildcard
static int alphabet_lua_add_wildcard(lua_State *L)
{
  GtAlphabet **alpha;
  const char *wildcard;
  alpha = check_alphabet(L, 1);
  wildcard = luaL_checkstring(L, 2);
  luaL_argcheck(L, strlen(wildcard) == 1, 2,
                "wildcard string must have length 0");
  gt_alphabet_add_wildcard(*alpha, wildcard[0]);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4f672(%rip), %rdx     # 0xdef73
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
movq %rax, %rdi
callq 0xb260
cmpq $0x1, %rax
je 0x8f93c
leaq 0x56c42(%rip), %rdx     # 0xe6573
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movsbl (%r15), %esi
callq 0x9afc9
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/alphabet_lua.c
// Function: alphabet_lua_decode
static int alphabet_lua_decode(lua_State *L)
{
  GtAlphabet **alpha;
  unsigned int code;
  char character;
  alpha = check_alphabet(L, 1);
  code = luaL_checkinteger(L, 2);
  /* XXX: too restrictive, does not consider wildcards */
  luaL_argcheck(L, code < gt_alphabet_size(*alpha), 2, "invalid code");
  character = gt_alphabet_decode(*alpha, code);
  lua_pushlstring(L, &character, 1);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4f610(%rip), %rdx     # 0xdef73
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
movq (%r14), %rdi
callq 0x9b5de
cmpl %r15d, %eax
ja 0x8f99b
leaq 0x56c06(%rip), %rdx     # 0xe6596
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movzbl %r15b, %esi
callq 0x9bed8
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x3828a
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/alphabet_lua.c
// Function: alphabet_lua_size
static int alphabet_lua_size(lua_State *L)
{
  GtAlphabet **alpha;
  unsigned int size;
  alpha = check_alphabet(L, 1);
  size = gt_alphabet_size(*alpha);
  lua_pushinteger(L, size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4f5a0(%rip), %rdx     # 0xdef73
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x3ae77
movq (%rax), %rdi
callq 0x9b5de
movl %eax, %esi
movq %rbx, %rdi
callq 0x38270
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/alphabet_lua.c
// Function: alphabet_lua_new_dna
static int alphabet_lua_new_dna(lua_State *L)
{
  GtAlphabet **alpha;
  gt_assert(L);
  alpha = lua_newuserdata(L, sizeof *alpha);
  gt_assert(alpha);
  *alpha = gt_alphabet_new_dna();
  gt_assert(*alpha);
  luaL_getmetatable(L, ALPHABET_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8fa4b
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x39c01
testq %rax, %rax
je 0x8fa75
movq %rax, %r14
callq 0x9b273
movq %rax, (%r14)
testq %rax, %rax
je 0x8fa9f
leaq 0x4f54b(%rip), %rdx     # 0xdef73
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9e566(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a60a(%rip), %rsi     # 0xca066
leaq 0x46f93(%rip), %rdx     # 0xd69f6
leaq 0x56b4c(%rip), %rcx     # 0xe65b6
leaq 0x56a9d(%rip), %r8      # 0xe650e
pushq $0x35
jmp 0x8fac7
movq 0x9e53c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a5e0(%rip), %rsi     # 0xca066
leaq 0x56a9f(%rip), %rdx     # 0xe652c
leaq 0x56b22(%rip), %rcx     # 0xe65b6
leaq 0x56a73(%rip), %r8      # 0xe650e
pushq $0x37
jmp 0x8fac7
movq 0x9e512(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a5b6(%rip), %rsi     # 0xca066
leaq 0x576a7(%rip), %rdx     # 0xe715e
leaq 0x56af8(%rip), %rcx     # 0xe65b6
leaq 0x56a49(%rip), %r8      # 0xe650e
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/alphabet_lua.c
// Function: alphabet_lua_new_protein
static int alphabet_lua_new_protein(lua_State *L)
{
  GtAlphabet **alpha;
  gt_assert(L);
  alpha = lua_newuserdata(L, sizeof *alpha);
  gt_assert(alpha);
  *alpha = gt_alphabet_new_protein();
  gt_assert(*alpha);
  luaL_getmetatable(L, ALPHABET_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8fb28
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x39c01
testq %rax, %rax
je 0x8fb52
movq %rax, %r14
callq 0x9b369
movq %rax, (%r14)
testq %rax, %rax
je 0x8fb7c
leaq 0x4f46e(%rip), %rdx     # 0xdef73
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9e489(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a52d(%rip), %rsi     # 0xca066
leaq 0x46eb6(%rip), %rdx     # 0xd69f6
leaq 0x56a84(%rip), %rcx     # 0xe65cb
leaq 0x569c0(%rip), %r8      # 0xe650e
pushq $0x1b
jmp 0x8fba4
movq 0x9e45f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a503(%rip), %rsi     # 0xca066
leaq 0x569c2(%rip), %rdx     # 0xe652c
leaq 0x56a5a(%rip), %rcx     # 0xe65cb
leaq 0x56996(%rip), %r8      # 0xe650e
pushq $0x1d
jmp 0x8fba4
movq 0x9e435(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a4d9(%rip), %rsi     # 0xca066
leaq 0x575ca(%rip), %rdx     # 0xe715e
leaq 0x56a30(%rip), %rcx     # 0xe65cb
leaq 0x5696c(%rip), %r8      # 0xe650e
pushq $0x1f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/alphabet_lua.c
// Function: alphabet_lua_new_empty
static int alphabet_lua_new_empty(lua_State *L)
{
  GtAlphabet **alpha;
  gt_assert(L);
  alpha = lua_newuserdata(L, sizeof *alpha);
  gt_assert(alpha);
  *alpha = gt_alphabet_new_empty();
  gt_assert(*alpha);
  luaL_getmetatable(L, ALPHABET_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8fc05
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x39c01
testq %rax, %rax
je 0x8fc2f
movq %rax, %r14
callq 0x9b167
movq %rax, (%r14)
testq %rax, %rax
je 0x8fc59
leaq 0x4f391(%rip), %rdx     # 0xdef73
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9e3ac(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a450(%rip), %rsi     # 0xca066
leaq 0x46dd9(%rip), %rdx     # 0xd69f6
leaq 0x569c0(%rip), %rcx     # 0xe65e4
leaq 0x568e3(%rip), %r8      # 0xe650e
pushq $0x28
jmp 0x8fc81
movq 0x9e382(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a426(%rip), %rsi     # 0xca066
leaq 0x568e5(%rip), %rdx     # 0xe652c
leaq 0x56996(%rip), %rcx     # 0xe65e4
leaq 0x568b9(%rip), %r8      # 0xe650e
pushq $0x2a
jmp 0x8fc81
movq 0x9e358(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a3fc(%rip), %rsi     # 0xca066
leaq 0x574ed(%rip), %rdx     # 0xe715e
leaq 0x5696c(%rip), %rcx     # 0xe65e4
leaq 0x5688f(%rip), %r8      # 0xe650e
pushq $0x2c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/annotationsketch_lua.c
// Function: gt_lua_open_annotationsketch
int gt_lua_open_annotationsketch(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  gt_lua_open_canvas(L);
  gt_lua_open_diagram(L);
  gt_lua_open_imageinfo(L);
  gt_lua_open_layout(L);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8fcd8
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
movq %rbx, %rdi
callq 0x901ac
movq %rbx, %rdi
callq 0x90800
movq %rbx, %rdi
callq 0x95040
movq %rbx, %rdi
callq 0x9550c
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x8fd02
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x9e2d9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a37d(%rip), %rsi     # 0xca066
leaq 0x46d06(%rip), %rdx     # 0xd69f6
leaq 0x56904(%rip), %rcx     # 0xe65fb
leaq 0x5691a(%rip), %r8      # 0xe6618
pushq $0x1e
jmp 0x8fd2a
movq 0x9e2af(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a353(%rip), %rsi     # 0xca066
leaq 0x4e0c1(%rip), %rdx     # 0xddddb
leaq 0x568da(%rip), %rcx     # 0xe65fb
leaq 0x568f0(%rip), %r8      # 0xe6618
pushq $0x26
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/bittab_lua.c
// Function: gt_lua_open_bittab
int gt_lua_open_bittab(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, BITTAB_METATABLE);
  /* metatable.__index = metatable */
  lua_pushvalue(L, -1); /* duplicate the metatable */
  lua_setfield(L, -2, "__index");
  /* set its _gc field */
  lua_pushstring(L, "__gc");
  lua_pushcfunction(L, bittab_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, bittab_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", bittab_lib_f);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8fdfb
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x5690d(%rip), %rsi     # 0xe6663
movq %rbx, %rdi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x4750e(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f41
leaq 0x46e4c(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xcc(%rip), %rsi        # 0x8fe61
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0x9d2ef(%rip), %rdx     # 0x12d0a0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
leaq 0x5a4aa(%rip), %rsi     # 0xea277
leaq 0x9d33c(%rip), %rdx     # 0x12d110
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x8fe29
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x9e1b6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a25a(%rip), %rsi     # 0xca066
leaq 0x46be3(%rip), %rdx     # 0xd69f6
leaq 0x5681f(%rip), %rcx     # 0xe6639
leaq 0x5682b(%rip), %r8      # 0xe664c
movl $0x8b, %r9d
jmp 0x8fe55
movq 0x9e188(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3a22c(%rip), %rsi     # 0xca066
leaq 0x4df9a(%rip), %rdx     # 0xddddb
leaq 0x567f1(%rip), %rcx     # 0xe6639
leaq 0x567fd(%rip), %r8      # 0xe664c
movl $0x9c, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/bittab_lua.c
// Function: get_bittab_and_bit
static void get_bittab_and_bit(lua_State *L, GtBittab ***bittab, GtWord *bit)
{
  *bittab = check_bittab(L, 1);
  *bit = luaL_checklong(L, 2);
  luaL_argcheck(L, *bit >= 0, 2, "bit number too small");
  luaL_argcheck(L, *bit < gt_bittab_size(**bittab), 2, "bit number too large");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x5667c(%rip), %rdx     # 0xe6663
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, (%r14)
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r12
movq %rax, (%r15)
testq %rax, %rax
jns 0x9001d
leaq 0x56667(%rip), %rdx     # 0xe6676
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r15), %r12
movq (%r14), %rax
movq (%rax), %rdi
callq 0x4df60
cmpq %rax, %r12
jae 0x90039
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5664b(%rip), %rdx     # 0xe668b
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3ab1c
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/bittab_lua.c
// Function: get_two_bittabs
static void get_two_bittabs(lua_State *L, GtBittab ***bt1, GtBittab ***bt2)
{
 *bt1 = check_bittab(L, 1);
 *bt2 = check_bittab(L, 2);
 luaL_argcheck(L, gt_bittab_size(**bt1) == gt_bittab_size(**bt2), 1,
               "bittabs have different sizes");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x565f5(%rip), %r12     # 0xe6663
pushq $0x1
popq %rsi
movq %r12, %rdx
callq 0x3ae77
movq %rax, (%r15)
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3ae77
movq %rax, (%r14)
movq (%r15), %rax
movq (%rax), %rdi
callq 0x4df60
movq %rax, %r15
movq (%r14), %rax
movq (%rax), %rdi
callq 0x4df60
cmpq %rax, %r15
jne 0x900b7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x565e2(%rip), %rdx     # 0xe66a0
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3ab1c