LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: show_nucleotide_values
static void show_nucleotide_values(NucEval *nucleotides, const char *level,
                                   GtFile *outfp)
{
  double sensitivity = 1.0, specificity = 1.0;
  gt_assert(nucleotides && level);
  if (nucleotides->TP || nucleotides->FN) {
    sensitivity = (double) nucleotides->TP /
                  (nucleotides->TP + nucleotides->FN);
  }
  if (nucleotides->TP || nucleotides->FP) {
    specificity = (double) nucleotides->TP /
                  (nucleotides->TP + nucleotides->FP);
  }
  gt_file_xprintf(outfp, "nucleotide sensitivity (%s level): %6.2f%% (TP="
                  GT_WU "/(TP=" GT_WU " + FN=" GT_WU "))\n", level,
                  sensitivity * 100.0, nucleotides->TP, nucleotides->TP,
                  nucleotides->FN);
  gt_file_xprintf(outfp, "nucleotide specificity (%s level): %6.2f%% (TP="
                  GT_WU "/(TP=" GT_WU " + FP=" GT_WU "))\n", level,
                  specificity * 100.0, nucleotides->TP, nucleotides->TP,
                  nucleotides->FP);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xab76b
movq %rsi, %rbx
testq %rsi, %rsi
je 0xab76b
movq %rdx, %r14
movq %rdi, %r15
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testq %rcx, %rcx
je 0xab6a2
movq %rcx, %xmm0
movq 0x35e2d(%rip), %xmm2    # 0xe1480
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
movapd 0x35e31(%rip), %xmm3    # 0xe1490
subpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq 0x10(%r15), %r9
leaq (%r9,%rcx), %rdx
movq %rdx, %xmm0
punpckldq %xmm2, %xmm0    # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1]
subpd %xmm3, %xmm0
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
movapd %xmm1, %xmm0
divsd %xmm2, %xmm0
mulsd 0x400d0(%rip), %xmm0    # 0xeb770
jmp 0xab6ed
movq 0x10(%r15), %r9
xorpd %xmm1, %xmm1
movsd 0x400be(%rip), %xmm3    # 0xeb770
movapd %xmm3, %xmm0
testq %r9, %r9
je 0xab6e8
movq %r9, %xmm0
punpckldq 0x35db8(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x35dc0(%rip), %xmm0    # 0xe1490
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
addsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
divsd %xmm2, %xmm0
mulsd %xmm3, %xmm0
testq %rax, %rax
je 0xab721
addq %rcx, %rax
movq %rax, %xmm2
punpckldq 0x35d83(%rip), %xmm2 # xmm2 = xmm2[0],mem[0],xmm2[1],mem[1]
subpd 0x35d8b(%rip), %xmm2    # 0xe1490
movapd %xmm2, %xmm3
unpckhpd %xmm2, %xmm3            # xmm3 = xmm3[1],xmm2[1]
addsd %xmm2, %xmm3
divsd %xmm3, %xmm1
mulsd 0x40053(%rip), %xmm1    # 0xeb770
movapd %xmm1, %xmm3
movsd %xmm3, 0x8(%rsp)
leaq 0x514a0(%rip), %rsi     # 0xfcbce
movq %r14, %rdi
movq %rbx, %rdx
movq %rcx, %r8
movb $0x1, %al
callq 0x75ce5
movq (%r15), %rcx
movq 0x8(%r15), %r9
leaq 0x514c9(%rip), %rsi     # 0xfcc15
movq %r14, %rdi
movq %rbx, %rdx
movsd 0x8(%rsp), %xmm0
movq %rcx, %r8
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x75ce5
callq 0x24f6e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: gt_stream_evaluator_delete
void gt_stream_evaluator_delete(GtStreamEvaluator *se)
{
  if (!se) return;
  gt_node_stream_delete(se->reference);
  gt_node_stream_delete(se->prediction);
  gt_hashmap_delete(se->slots);
  gt_evaluator_delete(se->mRNA_gene_evaluator);
  gt_evaluator_delete(se->CDS_gene_evaluator);
  gt_evaluator_delete(se->mRNA_mRNA_evaluator);
  gt_evaluator_delete(se->CDS_mRNA_evaluator);
  gt_evaluator_delete(se->LTR_evaluator);
  gt_transcript_evaluators_delete(se->mRNA_exon_evaluators);
  gt_transcript_evaluators_delete(se->mRNA_exon_evaluators_collapsed);
  gt_transcript_evaluators_delete(se->CDS_exon_evaluators);
  gt_transcript_evaluators_delete(se->CDS_exon_evaluators_collapsed);
  gt_free(se);
}

// Assembly:
testq %rdi, %rdi
je 0xab7fd
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x48d02
movq 0x8(%rbx), %rdi
callq 0x48d02
movq 0x20(%rbx), %rdi
callq 0x77bab
movq 0x28(%rbx), %rdi
callq 0xdbc27
movq 0x30(%rbx), %rdi
callq 0xdbc27
movq 0x38(%rbx), %rdi
callq 0xdbc27
movq 0x40(%rbx), %rdi
callq 0xdbc27
movq 0x48(%rbx), %rdi
callq 0xdbc27
movq 0x50(%rbx), %rdi
callq 0xaca6f
movq 0x58(%rbx), %rdi
callq 0xaca6f
movq 0x60(%rbx), %rdi
callq 0xaca6f
movq 0x68(%rbx), %rdi
callq 0xaca6f
leaq 0x508f5(%rip), %rsi     # 0xfc0e4
movq %rbx, %rdi
movl $0x666, %edx            # imm = 0x666
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: add_real_exon
static void add_real_exon(GtTranscriptExons *te, GtRange range,
                          GtFeatureNode *fn)
{
  gt_assert(te);
  gt_array_add(gt_transcript_exons_get_all(te), range);
  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_array_add(gt_transcript_exons_get_single(te), range);
      break;
    case TRANSCRIPT_FEATURE_TYPE_INITIAL:
      gt_array_add(gt_transcript_exons_get_initial(te), range);
      break;
    case TRANSCRIPT_FEATURE_TYPE_INTERNAL:
      gt_array_add(gt_transcript_exons_get_internal(te), range);
      break;
    case TRANSCRIPT_FEATURE_TYPE_TERMINAL:
      gt_array_add(gt_transcript_exons_get_terminal(te), range);
      break;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rdi, %rdi
je 0xab8b6
movq %rcx, %r14
movq %rdi, %rbx
callq 0xacb20
movq %rsp, %rsi
movl $0x10, %edx
movq %rax, %rdi
callq 0x6f240
movq %r14, %rdi
callq 0x4016f
cmpl $0x4, %eax
ja 0xab8ad
movl %eax, %eax
leaq 0x5084b(%rip), %rcx     # 0xfc094
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0xacb3f
jmp 0xab89d
movq %r14, %rdi
callq 0x41592
movl %eax, %ebp
movq %r14, %rdi
callq 0x41572
leaq 0x50c06(%rip), %rdi     # 0xfc47b
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3d110
movq %rbx, %rdi
callq 0xacb2f
jmp 0xab89d
movq %rbx, %rdi
callq 0xacb4f
jmp 0xab89d
movq %rbx, %rdi
callq 0xacb5f
movq %rsp, %rsi
movl $0x10, %edx
movq %rax, %rdi
callq 0x6f240
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x24fa7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: add_nucleotide_exon
static void add_nucleotide_exon(GtBittab *nucleotides, GtRange range,
                                GtRange real_range, GtUword *FP)
{
  GtUword i;
  gt_assert(nucleotides);
  for (i = range.start; i <= range.end; i++) {
    if (gt_range_within(&real_range, i)) {
      gt_assert(i >= real_range.start);
      gt_bittab_set_bit(nucleotides, i - real_range.start);
    }
    else {
      gt_assert(FP);
      (*FP)++;
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, (%rsp)
movq %r8, 0x8(%rsp)
testq %rdi, %rdi
je 0xab934
movq %rdx, %r14
movq %rsi, %r15
cmpq %rdx, %rsi
ja 0xab91c
movq %r9, %rbx
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x7e28e
testb %al, %al
je 0xab90c
movq %r15, %rsi
subq (%rsp), %rsi
jb 0xab92a
movq %r12, %rdi
callq 0x70d40
jmp 0xab914
testq %rbx, %rbx
je 0xab92f
incq (%rbx)
incq %r15
cmpq %r14, %r15
jbe 0xab8ea
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x25019
callq 0x24fe0
callq 0x25052
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stream_evaluator.c
// Function: mRNAs_are_equal
static bool mRNAs_are_equal(GtGenomeNode *gn_1, GtGenomeNode *gn_2,
                            const char *feature_type)
{
  GtArray *exons_1, *exons_2;
  StoreExonFeatureInfo info;
  bool equal;
  GT_UNUSED int had_err;

  gt_assert(gn_1 && gn_2 && feature_type);

  /* init */
  exons_1 = gt_array_new(sizeof (GtRange));
  exons_2 = gt_array_new(sizeof (GtRange));

  /* get exon ranges */
  info.exons = exons_1;
  info.feature_type = feature_type;
  had_err = gt_feature_node_traverse_children(gt_feature_node_cast(gn_1), &info,
                                              store_exon, false, NULL);
  gt_assert(!had_err); /* cannot happen, store_exon() is sane */
  info.exons = exons_2;
  had_err = gt_feature_node_traverse_children(gt_feature_node_cast(gn_2), &info,
                                              store_exon, false, NULL);
  gt_assert(!had_err); /* cannot happen, store_exon() is sane */

  /* sort exon ranges */
  gt_ranges_sort(exons_1);
  gt_ranges_sort(exons_2);

  /* compare exon ranges */
  equal = gt_ranges_are_equal(exons_1, exons_2);

  /* free */
  gt_array_delete(exons_1);
  gt_array_delete(exons_2);

  return equal;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xabd6b
movq %rsi, %r15
testq %rsi, %rsi
je 0xabd6b
movq %rdx, %r13
testq %rdx, %rdx
je 0xabd6b
movq %rdi, %r12
movl $0x10, %edi
callq 0x6ef7c
movq %rax, %rbx
movl $0x10, %edi
callq 0x6ef7c
movq %rax, %r14
leaq 0x8(%rsp), %rbp
movq %rbx, (%rbp)
movq %r13, 0x8(%rbp)
movq %r12, %rdi
callq 0x3f369
leaq 0x61a(%rip), %rdx       # 0xac307
movq %rax, %rdi
movq %rbp, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3fd29
testl %eax, %eax
jne 0xabd70
leaq 0x8(%rsp), %r12
movq %r14, (%r12)
movq %r15, %rdi
callq 0x3f369
leaq 0x5ee(%rip), %rdx       # 0xac307
movq %rax, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x3fd29
testl %eax, %eax
jne 0xabd75
movq %rbx, %rdi
callq 0x7ea1b
movq %r14, %rdi
callq 0x7ea1b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7eba7
movl %eax, %ebp
movq %rbx, %rdi
callq 0x6f768
movq %r14, %rdi
callq 0x6f768
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x251a8
callq 0x251e1
callq 0x2521a
// File: /workspace/github_c_makefile_star2_O3/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 0xabe28
movq %rsi, %r14
testq %rsi, %rsi
je 0xabe28
movq %rdi, %rbx
callq 0xac95f
movl $0x1, %esi
movq %rax, %rdi
callq 0xdb16a
movq %r14, %rdi
callq 0x4016f
cmpl $0x4, %eax
ja 0xabe23
movl %eax, %eax
leaq 0x502ea(%rip), %rcx     # 0xfc0a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0xac97e
jmp 0xabe12
movq %r14, %rdi
callq 0x41592
movl %eax, %ebp
movq %r14, %rdi
callq 0x41572
leaq 0x50691(%rip), %rdi     # 0xfc47b
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3d110
movq %rbx, %rdi
callq 0xac96e
jmp 0xabe12
movq %rbx, %rdi
callq 0xac98e
jmp 0xabe12
movq %rbx, %rdi
callq 0xac99e
movl $0x1, %esi
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xdb16a
popq %rbx
popq %r14
popq %rbp
retq
callq 0x25253
// File: /workspace/github_c_makefile_star2_O3/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 0xacda2
movq %rax, %r13
movq %r14, %rdi
callq 0xac95f
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xac374
movq %r12, %rdi
callq 0x4016f
cmpl $0x4, %eax
ja 0xabee8
movl %eax, %eax
leaq 0x50246(%rip), %rcx     # 0xfc0bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rdi
callq 0xacdb1
movq %rax, %r15
movq %r14, %rdi
callq 0xac96e
jmp 0xabed1
movq %r15, %rdi
callq 0xacde1
movq %rax, %r15
movq %r14, %rdi
callq 0xac99e
jmp 0xabed1
movq %r15, %rdi
callq 0xacdc1
movq %rax, %r15
movq %r14, %rdi
callq 0xac97e
jmp 0xabed1
movq %r15, %rdi
callq 0xacdd1
movq %rax, %r15
movq %r14, %rdi
callq 0xac98e
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xac374
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xac297
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0xac302
testq %rbx, %rbx
je 0xac2fd
testq %r14, %r14
je 0xac2fd
leaq 0x38982(%rip), %rsi     # 0xe4c2a
movq %r14, %rdi
callq 0x3faa4
testb %al, %al
je 0xac2c2
movq 0x8(%rbx), %rdi
movq %rsp, %rsi
movl $0x8, %edx
jmp 0xac2ee
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x3faa4
testb %al, %al
je 0xac2f3
movq %r14, %rdi
callq 0x415e5
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq (%rbx), %rdi
movl $0x10, %edx
callq 0x6f240
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x252fe
callq 0x252c5
// File: /workspace/github_c_makefile_star2_O3/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 0xac325
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0xac36f
testq %r14, %r14
je 0xac36a
testq %rbx, %rbx
je 0xac36a
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x3faa4
testb %al, %al
je 0xac360
movq %r14, %rdi
callq 0x415e5
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq (%rbx), %rdi
movl $0x10, %edx
callq 0x6f240
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x25370
callq 0x25337
// File: /workspace/github_c_makefile_star2_O3/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 0x73328
testq %rax, %rax
je 0xac392
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4fd4b(%rip), %rsi     # 0xfc0e4
movl $0x10, %edi
movl $0x2e8, %edx            # imm = 0x2E8
callq 0x35862
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x733b1
movl $0x1, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xdb16a
// File: /workspace/github_c_makefile_star2_O3/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 0x40a6c
testl %ebp, %ebp
je 0xac596
movq %rbx, %rdi
xorl %esi, %esi
callq 0x858a4
leaq 0x3de83(%rip), %rdi     # 0xea40e
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb9c0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xac6b4
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x353a2
testb %al, %al
je 0xac64d
leaq 0x424fa(%rip), %rdi     # 0xeeb01
movq %r13, %rsi
xorl %eax, %eax
callq 0x353ae
leaq 0x503c8(%rip), %rdi     # 0xfc9e0
xorl %eax, %eax
callq 0x353ae
callq 0x35455
movq %r15, %rdi
movq %rax, %rsi
callq 0x71295
leaq 0x503b5(%rip), %rdi     # 0xfc9eb
xorl %eax, %eax
callq 0x353ae
callq 0x35455
movq %r12, %rdi
movq %rax, %rsi
callq 0x71295
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x70e38
movq %r14, %rdi
callq 0x71242
addq %rax, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x70d90
movq %r14, %rdi
movq %r12, %rsi
callq 0x70f43
movq %r14, %rdi
callq 0x71242
addq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x70d90
movq %r14, %rdi
movq %r15, %rsi
callq 0x70f43
movq %r14, %rdi
callq 0x71242
addq %rax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x253a9
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x5057f(%rip), %rdx     # 0xfcc5c
movl $0x1, %edi
movl $0x28, %esi
movl $0x23, %ecx
callq 0x359a6
movq %rax, %r15
testq %rbx, %rbx
je 0xac704
movq %rbx, %rdi
callq 0x70cd4
movq %rax, (%r15)
testq %rbp, %rbp
je 0xac715
movq %rbp, %rdi
callq 0x70cd4
movq %rax, 0x8(%r15)
testq %r13, %r13
je 0xac726
movq %r13, %rdi
callq 0x70cd4
movq %rax, 0x10(%r15)
testq %r12, %r12
je 0xac737
movq %r12, %rdi
callq 0x70cd4
movq %rax, 0x18(%r15)
testq %r14, %r14
je 0xac748
movq %rbx, %rdi
callq 0x70cd4
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_O3/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 0xac7f3
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x713d5
movq 0x8(%rbx), %rdi
callq 0x713d5
movq 0x10(%rbx), %rdi
callq 0x713d5
movq 0x18(%rbx), %rdi
callq 0x713d5
movq 0x20(%rbx), %rdi
callq 0x713d5
leaq 0x50477(%rip), %rsi     # 0xfcc5c
movq %rbx, %rdi
movl $0x52, %edx
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xac910
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6f768
movq 0x8(%rbx), %rdi
callq 0x6f768
movq 0x10(%rbx), %rdi
callq 0x6f768
movq 0x18(%rbx), %rdi
callq 0x6f768
movq 0x20(%rbx), %rdi
callq 0x6f768
leaq 0x50426(%rip), %rsi     # 0xfcd28
movq %rbx, %rdi
movl $0x67, %edx
popq %rbx
jmp 0x35c27
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x5057e(%rip), %rsi     # 0xfce9a
movl $0x28, %edi
movl $0x1f, %edx
callq 0x35862
movq %rax, %rbx
callq 0xdb118
movq %rax, (%rbx)
callq 0xdb118
movq %rax, 0x8(%rbx)
callq 0xdb118
movq %rax, 0x10(%rbx)
callq 0xdb118
movq %rax, 0x18(%rbx)
callq 0xdb118
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xaca6a
movq %rsi, %rbx
testq %rsi, %rsi
je 0xaca6a
movq %rdi, %r14
movq (%rdi), %r15
movq %rbx, %rdi
callq 0xacb20
movq %rax, %rdi
callq 0x6f310
movq %r15, %rdi
movq %rax, %rsi
callq 0xdb15a
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0xacb2f
movq %rax, %rdi
callq 0x6f310
movq %r15, %rdi
movq %rax, %rsi
callq 0xdb15a
movq 0x10(%r14), %r15
movq %rbx, %rdi
callq 0xacb3f
movq %rax, %rdi
callq 0x6f310
movq %r15, %rdi
movq %rax, %rsi
callq 0xdb15a
movq 0x18(%r14), %r15
movq %rbx, %rdi
callq 0xacb4f
movq %rax, %rdi
callq 0x6f310
movq %r15, %rdi
movq %rax, %rsi
callq 0xdb15a
movq 0x20(%r14), %r14
movq %rbx, %rdi
callq 0xacb5f
movq %rax, %rdi
callq 0x6f310
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xdb15a
callq 0x2582e
// File: /workspace/github_c_makefile_star2_O3/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 0xacab9
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xdbc27
movq 0x8(%rbx), %rdi
callq 0xdbc27
movq 0x10(%rbx), %rdi
callq 0xdbc27
movq 0x18(%rbx), %rdi
callq 0xdbc27
movq 0x20(%rbx), %rdi
callq 0xdbc27
leaq 0x503ef(%rip), %rsi     # 0xfce9a
movq %rbx, %rdi
movl $0x63, %edx
popq %rbx
jmp 0x35c27
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
leaq 0x504ea(%rip), %rsi     # 0xfcfae
movl $0x28, %edi
movl $0x20, %edx
callq 0x35862
movq %rax, %rbx
movl $0x10, %edi
callq 0x6ef7c
movq %rax, (%rbx)
movl $0x10, %edi
callq 0x6ef7c
movq %rax, 0x8(%rbx)
movl $0x10, %edi
callq 0x6ef7c
movq %rax, 0x10(%rbx)
movl $0x10, %edi
callq 0x6ef7c
movq %rax, 0x18(%rbx)
movl $0x10, %edi
callq 0x6ef7c
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xacba5
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x7ea1b
movq 0x8(%rbx), %rdi
callq 0x7ea1b
movq 0x10(%rbx), %rdi
callq 0x7ea1b
movq 0x18(%rbx), %rdi
callq 0x7ea1b
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x7ea1b
callq 0x25978
// File: /workspace/github_c_makefile_star2_O3/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 0xacc2c
movq %rdi, %r14
callq 0xac7f4
movq %rax, %rbx
movq (%r14), %rdi
callq 0x7ea06
movq %rbx, %rdi
movq %rax, %rsi
callq 0xac81e
movq 0x8(%r14), %rdi
callq 0x7ea06
movq %rbx, %rdi
movq %rax, %rsi
callq 0xac842
movq 0x10(%r14), %rdi
callq 0x7ea06
movq %rbx, %rdi
movq %rax, %rsi
callq 0xac867
movq 0x18(%r14), %rdi
callq 0x7ea06
movq %rbx, %rdi
movq %rax, %rsi
callq 0xac88c
movq 0x20(%r14), %rdi
callq 0x7ea06
movq %rbx, %rdi
movq %rax, %rsi
callq 0xac8b1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x259af
// File: /workspace/github_c_makefile_star2_O3/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 0xacc7b
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x7ea99
testb %al, %al
je 0xacc77
movq 0x8(%rbx), %rdi
callq 0x7ea99
testb %al, %al
je 0xacc77
movq 0x10(%rbx), %rdi
callq 0x7ea99
testb %al, %al
je 0xacc77
movq 0x18(%rbx), %rdi
callq 0x7ea99
testb %al, %al
je 0xacc77
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x7ea99
xorl %eax, %eax
popq %rbx
retq
callq 0x259e6
// File: /workspace/github_c_makefile_star2_O3/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 0xacce6
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6f310
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x6f310
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x6f310
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x6f310
movq %rax, %r13
movq 0x20(%rbx), %rdi
callq 0x6f310
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 0xac6bc
callq 0x25a1d
// File: /workspace/github_c_makefile_star2_O3/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 0xacd35
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6f768
movq 0x8(%rbx), %rdi
callq 0x6f768
movq 0x10(%rbx), %rdi
callq 0x6f768
movq 0x18(%rbx), %rdi
callq 0x6f768
movq 0x20(%rbx), %rdi
callq 0x6f768
leaq 0x50287(%rip), %rsi     # 0xfcfae
movq %rbx, %rdi
movl $0x83, %edx
popq %rbx
jmp 0x35c27
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x503ab(%rip), %rsi     # 0xfd0ee
movl $0x28, %edi
movl $0x20, %edx
callq 0x35862
movq %rax, %rbx
leaq -0x2ecc0(%rip), %r14    # 0x7e09c
movq %r14, %rdi
callq 0x7329c
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x7329c
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x7329c
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x7329c
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x7329c
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xace3b
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xace3c
movq 0x8(%rbx), %rdi
callq 0xace3c
movq 0x10(%rbx), %rdi
callq 0xace3c
movq 0x18(%rbx), %rdi
callq 0xace3c
movq 0x20(%rbx), %rdi
callq 0xace3c
leaq 0x502c1(%rip), %rsi     # 0xfd0ee
movq %rbx, %rdi
movl $0x59, %edx
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x73308
testq %rax, %rax
je 0xace80
movq %rax, %r14
leaq 0x50296(%rip), %r15     # 0xfd0ee
movq %r14, %rdi
callq 0x73384
movq %rax, %rdi
movq %r15, %rsi
movl $0x4c, %edx
callq 0x35c27
movq %r14, %rdi
callq 0x73394
movq %rax, %r14
testq %rax, %rax
jne 0xace58
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x73601
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0xacf5c
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x48d66(%rip), %rsi     # 0xf5c13
movq %rbx, %rdi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x4140d(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x40d4d(%rip), %rsi     # 0xedc2a
movq %rbx, %rdi
callq 0x5790a
leaq 0x7a(%rip), %rsi        # 0xacf66
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0xa3126(%rip), %rdx     # 0x150030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
leaq 0x540d3(%rip), %rsi     # 0x100ffb
leaq 0xa3151(%rip), %rdx     # 0x150080
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0xacf61
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x25ba0
callq 0x25b67
// File: /workspace/github_c_makefile_star2_O3/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 0xacfcd
movq %rsi, %r14
testq %rsi, %rsi
je 0xacfcd
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
movq %r14, (%rax)
leaq 0x48c67(%rip), %rdx     # 0xf5c13
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x586d6
callq 0x25bd9
// File: /workspace/github_c_makefile_star2_O3/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 0x48c32(%rip), %rdx     # 0xf5c13
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0xad019
leaq 0x5020f(%rip), %rdx     # 0xfd21b
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq %r15, %rsi
callq 0xba0f5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x48bd8(%rip), %rdx     # 0xf5c13
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movq %rax, %rdi
callq 0xb260
cmpq $0x1, %rax
je 0xad07c
leaq 0x501d8(%rip), %rdx     # 0xfd247
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
movsbl (%r15), %esi
callq 0xba1d0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x48b70(%rip), %rdx     # 0xf5c13
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq (%r14), %rdi
callq 0xba7b3
cmpl %r15d, %eax
ja 0xad0e1
leaq 0x50196(%rip), %rdx     # 0xfd26a
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
movzbl %r15b, %esi
callq 0xbae5f
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x57747
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x48af8(%rip), %rdx     # 0xf5c13
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0xba7b3
movl %eax, %esi
movq %rbx, %rdi
callq 0x5772d
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xad197
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
testq %rax, %rax
je 0xad19c
movq %rax, %r14
callq 0xba4b2
movq %rax, (%r14)
testq %rax, %rax
je 0xad1a1
leaq 0x48aa3(%rip), %rdx     # 0xf5c13
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x25c80
callq 0x25c49
callq 0x25c12
// File: /workspace/github_c_makefile_star2_O3/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 0xad1ff
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
testq %rax, %rax
je 0xad204
movq %rax, %r14
callq 0xba5c1
movq %rax, (%r14)
testq %rax, %rax
je 0xad209
leaq 0x48a3b(%rip), %rdx     # 0xf5c13
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x25d25
callq 0x25cee
callq 0x25cb7
// File: /workspace/github_c_makefile_star2_O3/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 0xad267
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
testq %rax, %rax
je 0xad26c
movq %rax, %r14
callq 0xba34a
movq %rax, (%r14)
testq %rax, %rax
je 0xad271
leaq 0x489d3(%rip), %rdx     # 0xf5c13
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x25dca
callq 0x25d93
callq 0x25d5c
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xad2c2
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
movq %rbx, %rdi
callq 0xad6b0
movq %rbx, %rdi
callq 0xadbb8
movq %rbx, %rdi
callq 0xb1518
movq %rbx, %rdi
callq 0xb18c4
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0xad2c7
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x25e38
callq 0x25e01