LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xac266
movq %rsi, %rbx
testq %rsi, %rsi
je 0xac266
movq %rdx, %r14
movq %rdi, %r15
movq (%rdi), %rcx
movq %rcx, %xmm1
testq %rcx, %rcx
jne 0xac14b
cmpq $0x0, 0x10(%r15)
je 0xac24a
movq 0x3532d(%rip), %xmm2    # 0xe1480
movdqa %xmm1, %xmm3
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
movapd 0x3532d(%rip), %xmm4    # 0xe1490
subpd %xmm4, %xmm3
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0            # xmm0 = xmm0[1],xmm3[1]
addsd %xmm3, %xmm0
movq 0x10(%r15), %rax
addq %rcx, %rax
movq %rax, %xmm3
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
subpd %xmm4, %xmm3
movapd %xmm3, %xmm2
unpckhpd %xmm3, %xmm2            # xmm2 = xmm2[1],xmm3[1]
addsd %xmm3, %xmm2
divsd %xmm2, %xmm0
mulsd 0x3f621(%rip), %xmm0    # 0xeb7c0
testq %rcx, %rcx
jne 0xac1af
cmpq $0x0, 0x8(%r15)
je 0xac257
movq 0x352c9(%rip), %xmm2    # 0xe1480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x352cd(%rip), %xmm3    # 0xe1490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm4
unpckhpd %xmm1, %xmm4            # xmm4 = xmm4[1],xmm1[1]
addsd %xmm1, %xmm4
movq 0x8(%r15), %rax
addq %rcx, %rax
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm4
mulsd 0x3f5c1(%rip), %xmm4    # 0xeb7c0
movapd %xmm4, (%rsp)
movq 0x10(%r15), %r9
leaq 0x50a4f(%rip), %rsi     # 0xfcc5e
movq %r14, %rdi
movq %rbx, %rdx
movq %rcx, %r8
movb $0x1, %al
callq 0x757a1
movq (%r15), %rcx
movq 0x8(%r15), %r9
leaq 0x50a78(%rip), %rsi     # 0xfcca5
movq %r14, %rdi
movq %rbx, %rdx
movaps (%rsp), %xmm0
movq %rcx, %r8
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x757a1
movsd 0x3f56e(%rip), %xmm0    # 0xeb7c0
jmp 0xac19f
movsd 0x3f561(%rip), %xmm1    # 0xeb7c0
movapd %xmm1, (%rsp)
jmp 0xac204
callq 0x25085
// File: /workspace/github_c_makefile_star2_O1/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 0xac2f8
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x4996a
movq 0x8(%rbx), %rdi
callq 0x4996a
movq 0x20(%rbx), %rdi
callq 0x77675
movq 0x28(%rbx), %rdi
callq 0xdb56b
movq 0x30(%rbx), %rdi
callq 0xdb56b
movq 0x38(%rbx), %rdi
callq 0xdb56b
movq 0x40(%rbx), %rdi
callq 0xdb56b
movq 0x48(%rbx), %rdi
callq 0xdb56b
movq 0x50(%rbx), %rdi
callq 0xad5bb
movq 0x58(%rbx), %rdi
callq 0xad5bb
movq 0x60(%rbx), %rdi
callq 0xad5bb
movq 0x68(%rbx), %rdi
callq 0xad5bb
leaq 0x4fe8a(%rip), %rsi     # 0xfc174
movq %rbx, %rdi
movl $0x666, %edx            # imm = 0x666
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xac3b1
movq %rcx, %r14
movq %rdi, %rbx
callq 0xad66c
movq %rsp, %rsi
movl $0x10, %edx
movq %rax, %rdi
callq 0x6ec0e
movq %r14, %rdi
callq 0x40ad9
cmpl $0x4, %eax
ja 0xac3a8
movl %eax, %eax
leaq 0x4fde0(%rip), %rcx     # 0xfc124
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0xad68b
jmp 0xac398
movq %r14, %rdi
callq 0x41f30
movl %eax, %ebp
movq %r14, %rdi
callq 0x41f10
leaq 0x5019b(%rip), %rdi     # 0xfc50b
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3da84
movq %rbx, %rdi
callq 0xad67b
jmp 0xac398
movq %rbx, %rdi
callq 0xad69b
jmp 0xac398
movq %rbx, %rdi
callq 0xad6ab
movq %rsp, %rsi
movl $0x10, %edx
movq %rax, %rdi
callq 0x6ec0e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x250be
// File: /workspace/github_c_makefile_star2_O1/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 0xac42f
movq %rdx, %r14
movq %rsi, %r15
cmpq %rdx, %rsi
ja 0xac417
movq %r9, %rbx
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x7e14a
testb %al, %al
je 0xac407
movq %r15, %rsi
subq (%rsp), %rsi
jb 0xac425
movq %r12, %rdi
callq 0x70790
jmp 0xac40f
testq %rbx, %rbx
je 0xac42a
incq (%rbx)
incq %r15
cmpq %r14, %r15
jbe 0xac3e5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x25130
callq 0x250f7
callq 0x25169
// File: /workspace/github_c_makefile_star2_O1/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 0xac876
movq %rsi, %r15
testq %rsi, %rsi
je 0xac876
movq %rdx, %r13
testq %rdx, %rdx
je 0xac876
movq %rdi, %r12
movl $0x10, %edi
callq 0x6e93c
movq %rax, %rbx
movl $0x10, %edi
callq 0x6e93c
movq %rax, %r14
leaq 0x8(%rsp), %rbp
movq %rbx, (%rbp)
movq %r13, 0x8(%rbp)
movq %r12, %rdi
callq 0x3fcd9
leaq 0x61c(%rip), %rdx       # 0xace14
movq %rax, %rdi
movq %rbp, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4068e
testl %eax, %eax
jne 0xac87b
leaq 0x8(%rsp), %r12
movq %r14, (%r12)
movq %r15, %rdi
callq 0x3fcd9
leaq 0x5f0(%rip), %rdx       # 0xace14
movq %rax, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4068e
testl %eax, %eax
jne 0xac880
movq %rbx, %rdi
callq 0x7e92e
movq %r14, %rdi
callq 0x7e92e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7eb1a
movl %eax, %ebp
movq %rbx, %rdi
callq 0x6f134
movq %r14, %rdi
callq 0x6f134
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x252f8
callq 0x25331
callq 0x2536a
// File: /workspace/github_c_makefile_star2_O1/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 0xac933
movq %rsi, %r14
testq %rsi, %rsi
je 0xac933
movq %rdi, %rbx
callq 0xad4ab
movl $0x1, %esi
movq %rax, %rdi
callq 0xdaaae
movq %r14, %rdi
callq 0x40ad9
cmpl $0x4, %eax
ja 0xac92e
movl %eax, %eax
leaq 0x4f86f(%rip), %rcx     # 0xfc138
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0xad4ca
jmp 0xac91d
movq %r14, %rdi
callq 0x41f30
movl %eax, %ebp
movq %r14, %rdi
callq 0x41f10
leaq 0x4fc16(%rip), %rdi     # 0xfc50b
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3da84
movq %rbx, %rdi
callq 0xad4ba
jmp 0xac91d
movq %rbx, %rdi
callq 0xad4da
jmp 0xac91d
movq %rbx, %rdi
callq 0xad4ea
movl $0x1, %esi
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xdaaae
popq %rbx
popq %r14
popq %rbp
retq
callq 0x253a3
// File: /workspace/github_c_makefile_star2_O1/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 0xad8ee
movq %rax, %r13
movq %r14, %rdi
callq 0xad4ab
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xace81
movq %r12, %rdi
callq 0x40ad9
cmpl $0x4, %eax
ja 0xac9f3
movl %eax, %eax
leaq 0x4f7cb(%rip), %rcx     # 0xfc14c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rdi
callq 0xad8fd
movq %rax, %r15
movq %r14, %rdi
callq 0xad4ba
jmp 0xac9dc
movq %r15, %rdi
callq 0xad92d
movq %rax, %r15
movq %r14, %rdi
callq 0xad4ea
jmp 0xac9dc
movq %r15, %rdi
callq 0xad90d
movq %rax, %r15
movq %r14, %rdi
callq 0xad4ca
jmp 0xac9dc
movq %r15, %rdi
callq 0xad91d
movq %rax, %r15
movq %r14, %rdi
callq 0xad4da
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xace81
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
testq %rdx, %rdx
je 0xacd9e
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0xace0f
testq %rbx, %rbx
je 0xace0a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xace0a
leaq 0x37e96(%rip), %rsi     # 0xe4c4a
callq 0x40409
testb %al, %al
je 0xacdcd
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
jmp 0xacdfd
movq 0x8(%rsp), %rdi
movq 0x10(%rbx), %rsi
callq 0x40409
testb %al, %al
je 0xace02
movq 0x8(%rsp), %rdi
callq 0x41f83
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq (%rbx), %rdi
movl $0x10, %edx
callq 0x6ec0e
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
callq 0x2544e
callq 0x25415
// File: /workspace/github_c_makefile_star2_O1/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 0xace32
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0xace7c
testq %r14, %r14
je 0xace77
testq %rbx, %rbx
je 0xace77
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x40409
testb %al, %al
je 0xace6d
movq %r14, %rdi
callq 0x41f83
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq (%rbx), %rdi
movl $0x10, %edx
callq 0x6ec0e
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x254c0
callq 0x25487
// File: /workspace/github_c_makefile_star2_O1/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 0x72d50
testq %rax, %rax
je 0xace9f
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4f2ce(%rip), %rsi     # 0xfc174
movl $0x10, %edi
movl $0x2e8, %edx            # imm = 0x2E8
callq 0x35ee2
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x72dd9
movl $0x1, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xdaaae
// File: /workspace/github_c_makefile_star2_O1/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 0x413f5
testl %ebp, %ebp
je 0xad0e3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x85dd0
leaq 0x3d386(%rip), %rdi     # 0xea45e
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb9c0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xad201
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x35a26
testb %al, %al
je 0xad19a
leaq 0x419f5(%rip), %rdi     # 0xeeb49
movq %r13, %rsi
xorl %eax, %eax
callq 0x35a32
leaq 0x4f90b(%rip), %rdi     # 0xfca70
xorl %eax, %eax
callq 0x35a32
callq 0x35ad9
movq %r15, %rdi
movq %rax, %rsi
callq 0x70cf4
leaq 0x4f8f8(%rip), %rdi     # 0xfca7b
xorl %eax, %eax
callq 0x35a32
callq 0x35ad9
movq %r12, %rdi
movq %rax, %rsi
callq 0x70cf4
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x70885
movq %r14, %rdi
callq 0x70ca1
addq %rax, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x707e0
movq %r14, %rdi
movq %r12, %rsi
callq 0x70990
movq %r14, %rdi
callq 0x70ca1
addq %rax, 0x8(%rbx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x707e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x70990
movq %r14, %rdi
callq 0x70ca1
addq %rax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x254f9
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x4fac3(%rip), %rdx     # 0xfccec
movl $0x1, %edi
movl $0x28, %esi
movl $0x23, %ecx
callq 0x3601f
movq %rax, %r15
testq %rbx, %rbx
je 0xad250
movq %rbx, %rdi
callq 0x70724
movq %rax, (%r15)
testq %rbp, %rbp
je 0xad261
movq %rbp, %rdi
callq 0x70724
movq %rax, 0x8(%r15)
testq %r13, %r13
je 0xad272
movq %r13, %rdi
callq 0x70724
movq %rax, 0x10(%r15)
testq %r12, %r12
je 0xad283
movq %r12, %rdi
callq 0x70724
movq %rax, 0x18(%r15)
testq %r14, %r14
je 0xad294
movq %rbx, %rdi
callq 0x70724
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_O1/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 0xad33f
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x70e34
movq 0x8(%rbx), %rdi
callq 0x70e34
movq 0x10(%rbx), %rdi
callq 0x70e34
movq 0x18(%rbx), %rdi
callq 0x70e34
movq 0x20(%rbx), %rdi
callq 0x70e34
leaq 0x4f9bb(%rip), %rsi     # 0xfccec
movq %rbx, %rdi
movl $0x52, %edx
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xad45c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6f134
movq 0x8(%rbx), %rdi
callq 0x6f134
movq 0x10(%rbx), %rdi
callq 0x6f134
movq 0x18(%rbx), %rdi
callq 0x6f134
movq 0x20(%rbx), %rdi
callq 0x6f134
leaq 0x4f96a(%rip), %rsi     # 0xfcdb8
movq %rbx, %rdi
movl $0x67, %edx
popq %rbx
jmp 0x362a0
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x4fac2(%rip), %rsi     # 0xfcf2a
movl $0x28, %edi
movl $0x1f, %edx
callq 0x35ee2
movq %rax, %rbx
callq 0xdaa5c
movq %rax, (%rbx)
callq 0xdaa5c
movq %rax, 0x8(%rbx)
callq 0xdaa5c
movq %rax, 0x10(%rbx)
callq 0xdaa5c
movq %rax, 0x18(%rbx)
callq 0xdaa5c
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xad5b6
movq %rsi, %rbx
testq %rsi, %rsi
je 0xad5b6
movq %rdi, %r14
movq (%rdi), %r15
movq %rbx, %rdi
callq 0xad66c
movq %rax, %rdi
callq 0x6ecda
movq %r15, %rdi
movq %rax, %rsi
callq 0xdaa9e
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0xad67b
movq %rax, %rdi
callq 0x6ecda
movq %r15, %rdi
movq %rax, %rsi
callq 0xdaa9e
movq 0x10(%r14), %r15
movq %rbx, %rdi
callq 0xad68b
movq %rax, %rdi
callq 0x6ecda
movq %r15, %rdi
movq %rax, %rsi
callq 0xdaa9e
movq 0x18(%r14), %r15
movq %rbx, %rdi
callq 0xad69b
movq %rax, %rdi
callq 0x6ecda
movq %r15, %rdi
movq %rax, %rsi
callq 0xdaa9e
movq 0x20(%r14), %r14
movq %rbx, %rdi
callq 0xad6ab
movq %rax, %rdi
callq 0x6ecda
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xdaa9e
callq 0x2597e
// File: /workspace/github_c_makefile_star2_O1/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 0xad605
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xdb56b
movq 0x8(%rbx), %rdi
callq 0xdb56b
movq 0x10(%rbx), %rdi
callq 0xdb56b
movq 0x18(%rbx), %rdi
callq 0xdb56b
movq 0x20(%rbx), %rdi
callq 0xdb56b
leaq 0x4f933(%rip), %rsi     # 0xfcf2a
movq %rbx, %rdi
movl $0x63, %edx
popq %rbx
jmp 0x362a0
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x4fa2e(%rip), %rsi     # 0xfd03e
movl $0x28, %edi
movl $0x20, %edx
callq 0x35ee2
movq %rax, %rbx
movl $0x10, %edi
callq 0x6e93c
movq %rax, (%rbx)
movl $0x10, %edi
callq 0x6e93c
movq %rax, 0x8(%rbx)
movl $0x10, %edi
callq 0x6e93c
movq %rax, 0x10(%rbx)
movl $0x10, %edi
callq 0x6e93c
movq %rax, 0x18(%rbx)
movl $0x10, %edi
callq 0x6e93c
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xad6f1
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x7e92e
movq 0x8(%rbx), %rdi
callq 0x7e92e
movq 0x10(%rbx), %rdi
callq 0x7e92e
movq 0x18(%rbx), %rdi
callq 0x7e92e
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x7e92e
callq 0x25ac8
// File: /workspace/github_c_makefile_star2_O1/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 0xad778
movq %rdi, %r14
callq 0xad340
movq %rax, %rbx
movq (%r14), %rdi
callq 0x7e919
movq %rbx, %rdi
movq %rax, %rsi
callq 0xad36a
movq 0x8(%r14), %rdi
callq 0x7e919
movq %rbx, %rdi
movq %rax, %rsi
callq 0xad38e
movq 0x10(%r14), %rdi
callq 0x7e919
movq %rbx, %rdi
movq %rax, %rsi
callq 0xad3b3
movq 0x18(%r14), %rdi
callq 0x7e919
movq %rbx, %rdi
movq %rax, %rsi
callq 0xad3d8
movq 0x20(%r14), %rdi
callq 0x7e919
movq %rbx, %rdi
movq %rax, %rsi
callq 0xad3fd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x25aff
// File: /workspace/github_c_makefile_star2_O1/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 0xad7c7
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x7e9ac
testb %al, %al
je 0xad7c3
movq 0x8(%rbx), %rdi
callq 0x7e9ac
testb %al, %al
je 0xad7c3
movq 0x10(%rbx), %rdi
callq 0x7e9ac
testb %al, %al
je 0xad7c3
movq 0x18(%rbx), %rdi
callq 0x7e9ac
testb %al, %al
je 0xad7c3
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x7e9ac
xorl %eax, %eax
popq %rbx
retq
callq 0x25b36
// File: /workspace/github_c_makefile_star2_O1/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 0xad832
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6ecda
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x6ecda
movq %rax, %r15
movq 0x10(%rbx), %rdi
callq 0x6ecda
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x6ecda
movq %rax, %r13
movq 0x20(%rbx), %rdi
callq 0x6ecda
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 0xad208
callq 0x25b6d
// File: /workspace/github_c_makefile_star2_O1/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 0xad881
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6f134
movq 0x8(%rbx), %rdi
callq 0x6f134
movq 0x10(%rbx), %rdi
callq 0x6f134
movq 0x18(%rbx), %rdi
callq 0x6f134
movq 0x20(%rbx), %rdi
callq 0x6f134
leaq 0x4f7cb(%rip), %rsi     # 0xfd03e
movq %rbx, %rdi
movl $0x83, %edx
popq %rbx
jmp 0x362a0
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x4f8ef(%rip), %rsi     # 0xfd17e
movl $0x28, %edi
movl $0x20, %edx
callq 0x35ee2
movq %rax, %rbx
leaq -0x2f950(%rip), %r14    # 0x7df58
movq %r14, %rdi
callq 0x72cc4
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x72cc4
movq %rax, 0x8(%rbx)
movq %r14, %rdi
callq 0x72cc4
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0x72cc4
movq %rax, 0x18(%rbx)
movq %r14, %rdi
callq 0x72cc4
movq %rax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xad987
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xad988
movq 0x8(%rbx), %rdi
callq 0xad988
movq 0x10(%rbx), %rdi
callq 0xad988
movq 0x18(%rbx), %rdi
callq 0xad988
movq 0x20(%rbx), %rdi
callq 0xad988
leaq 0x4f805(%rip), %rsi     # 0xfd17e
movq %rbx, %rdi
movl $0x59, %edx
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x72d30
testq %rax, %rax
je 0xad9cc
movq %rax, %r14
leaq 0x4f7da(%rip), %r15     # 0xfd17e
movq %r14, %rdi
callq 0x72dac
movq %rax, %rdi
movq %r15, %rsi
movl $0x4c, %edx
callq 0x362a0
movq %r14, %rdi
callq 0x72dbc
movq %rax, %r14
testq %rax, %rax
jne 0xad9a4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x73029
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xadaa8
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x4827a(%rip), %rsi     # 0xf5c73
movq %rbx, %rdi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x40909(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x40249(%rip), %rsi     # 0xedc72
movq %rbx, %rdi
callq 0x58568
leaq 0x7a(%rip), %rsi        # 0xadab2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0xa25da(%rip), %rdx     # 0x150030
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
leaq 0x53613(%rip), %rsi     # 0x101087
leaq 0xa2605(%rip), %rdx     # 0x150080
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0xadaad
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x25cf0
callq 0x25cb7
// File: /workspace/github_c_makefile_star2_O1/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 0xadb19
movq %rsi, %r14
testq %rsi, %rsi
je 0xadb19
movq %rdi, %rbx
movl $0x8, %esi
callq 0x59e95
movq %r14, (%rax)
leaq 0x4817b(%rip), %rdx     # 0xf5c73
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x59337
callq 0x25d29
// File: /workspace/github_c_makefile_star2_O1/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 0x48146(%rip), %rdx     # 0xf5c73
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0xadb65
leaq 0x4f753(%rip), %rdx     # 0xfd2ab
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
movq %r15, %rsi
callq 0xb907d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x480ec(%rip), %rdx     # 0xf5c73
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movq %rax, %rdi
callq 0xb260
cmpq $0x1, %rax
je 0xadbc8
leaq 0x4f71c(%rip), %rdx     # 0xfd2d7
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
movsbl (%r15), %esi
callq 0xb9158
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x48084(%rip), %rdx     # 0xf5c73
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq (%r14), %rdi
callq 0xb96c8
cmpl %r15d, %eax
ja 0xadc2d
leaq 0x4f6da(%rip), %rdx     # 0xfd2fa
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
movzbl %r15b, %esi
callq 0xb9d4b
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x58391
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4800c(%rip), %rdx     # 0xf5c73
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0xb96c8
movl %eax, %esi
movq %rbx, %rdi
callq 0x58377
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xadce3
movq %rdi, %rbx
movl $0x8, %esi
callq 0x59e95
testq %rax, %rax
je 0xadce8
movq %rax, %r14
callq 0xb93b3
movq %rax, (%r14)
testq %rax, %rax
je 0xadced
leaq 0x47fb7(%rip), %rdx     # 0xf5c73
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x25dd0
callq 0x25d99
callq 0x25d62
// File: /workspace/github_c_makefile_star2_O1/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 0xadd4b
movq %rdi, %rbx
movl $0x8, %esi
callq 0x59e95
testq %rax, %rax
je 0xadd50
movq %rax, %r14
callq 0xb94cc
movq %rax, (%r14)
testq %rax, %rax
je 0xadd55
leaq 0x47f4f(%rip), %rdx     # 0xf5c73
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x25e75
callq 0x25e3e
callq 0x25e07
// File: /workspace/github_c_makefile_star2_O1/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 0xaddb3
movq %rdi, %rbx
movl $0x8, %esi
callq 0x59e95
testq %rax, %rax
je 0xaddb8
movq %rax, %r14
callq 0xb92a1
movq %rax, (%r14)
testq %rax, %rax
je 0xaddbd
leaq 0x47ee7(%rip), %rdx     # 0xf5c73
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x25f1a
callq 0x25ee3
callq 0x25eac
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xade0e
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
movq %rbx, %rdi
callq 0xae1ec
movq %rbx, %rdi
callq 0xae6f4
movq %rbx, %rdi
callq 0xb2050
movq %rbx, %rdi
callq 0xb23fc
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0xade13
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x25f88
callq 0x25f51