LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_visitor.c
// Function: gt_csa_visitor_class
const GtNodeVisitorClass* gt_csa_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (CSAVisitor),
                                    csa_visitor_free,
                                    csa_visitor_comment_node,
                                    csa_visitor_feature_node,
                                    csa_visitor_region_node,
                                    csa_visitor_sequence_node,
                                    csa_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc, csa_visitor_meta_node);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x4f21f
cmpq $0x0, 0x6d83a(%rip)     # 0x12fd98
jne 0xc25ac
leaq 0x2f6(%rip), %rax       # 0xc285d
movq %rax, (%rsp)
leaq 0x48(%rip), %rsi        # 0xc25ba
leaq 0x74(%rip), %rdx        # 0xc25ed
leaq 0x77(%rip), %rcx        # 0xc25f7
leaq 0x2a0(%rip), %r8        # 0xc2827
leaq 0x2a3(%rip), %r9        # 0xc2831
pushq $0x68
popq %rdi
callq 0x25f10
movq %rax, 0x6d7fb(%rip)     # 0x12fd98
leaq 0x2e5(%rip), %rsi       # 0xc2889
movq %rax, %rdi
callq 0x25f9f
callq 0x4f266
movq 0x6d7e0(%rip), %rax     # 0x12fd98
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_visitor.c
// Function: csa_visitor_free
static void csa_visitor_free(GtNodeVisitor *nv)
{
  CSAVisitor *csa_visitor = csa_visitor_cast(nv);
  gt_queue_delete(csa_visitor->gt_genome_node_buffer);
  gt_array_delete(csa_visitor->cluster);
  gt_str_delete(csa_visitor->gt_csa_source_str);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xc2550
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2603e
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x5b761
movq 0x20(%rbx), %rdi
callq 0x4c19d
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0x152db
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_visitor.c
// Function: gt_csa_visitor_new
GtNodeVisitor* gt_csa_visitor_new(GtUword join_length)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_csa_visitor_class());
  CSAVisitor *csa_visitor = csa_visitor_cast(nv);
  csa_visitor->gt_genome_node_buffer = gt_queue_new();
  csa_visitor->join_length = join_length;
  csa_visitor->cluster = gt_array_new(sizeof (GtFeatureNode*));
  csa_visitor->buffered_feature = NULL;
  csa_visitor->gt_csa_source_str = gt_str_new_cstr(GT_CSA_SOURCE_TAG);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0xc2550
movq %rax, %rdi
callq 0x25fe0
movq %rax, %rbx
callq 0xc2550
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2603e
movq %rax, %r15
callq 0x5b040
movq %rax, 0x10(%r15)
movq %r14, 0x18(%r15)
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x20(%r15)
andq $0x0, 0x28(%r15)
leaq 0x31c91(%rip), %rdi     # 0xf4574
callq 0x13da9
movq %rax, 0x60(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_visitor.c
// Function: get_exons
static void get_exons(GtArray *exon_ranges, const void *sa)
{
  GtFeatureNode *fn = *(GtFeatureNode**) sa;
  GT_UNUSED int had_err;
  gt_assert(exon_ranges && fn && gt_feature_node_has_type(fn, gt_ft_gene));
  had_err = gt_feature_node_traverse_children(fn, exon_ranges,
                                              csa_visitor_save_exon, false,
                                              NULL);
  gt_assert(!had_err); /* csa_visitor_save_exon() is sane */
  /* we got at least one exon */
  gt_assert(gt_array_size(exon_ranges));
  gt_assert(gt_ranges_are_sorted_and_do_not_overlap(exon_ranges));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc3500
movq (%rsi), %r14
testq %r14, %r14
je 0xc3500
movq %rdi, %rbx
leaq 0x3249c(%rip), %rsi     # 0xf5950
movq %r14, %rdi
callq 0x1987b
testb %al, %al
je 0xc3500
leaq 0x172(%rip), %rdx       # 0xc3639
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x19e82
testl %eax, %eax
jne 0xc3531
movq %rbx, %rdi
callq 0x4b988
testq %rax, %rax
je 0xc355f
movq %rbx, %rdi
callq 0x5dd6d
testb %al, %al
je 0xc358d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x6aab1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6b55(%rip), %rsi      # 0xca066
leaq 0x311ad(%rip), %rdx     # 0xf46c5
leaq 0x3238a(%rip), %rcx     # 0xf58a9
leaq 0x310bb(%rip), %r8      # 0xf45e1
movl $0xe0, %r9d
jmp 0xc35b9
movq 0x6aa80(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6b24(%rip), %rsi      # 0xca066
leaq 0x70ca(%rip), %rdx      # 0xca613
leaq 0x32359(%rip), %rcx     # 0xf58a9
leaq 0x3108a(%rip), %r8      # 0xf45e1
movl $0xe4, %r9d
jmp 0xc35b9
movq 0x6aa52(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6af6(%rip), %rsi      # 0xca066
leaq 0x3118c(%rip), %rdx     # 0xf4703
leaq 0x3232b(%rip), %rcx     # 0xf58a9
leaq 0x3105c(%rip), %r8      # 0xf45e1
movl $0xe6, %r9d
jmp 0xc35b9
movq 0x6aa24(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6ac8(%rip), %rsi      # 0xca066
leaq 0x31179(%rip), %rdx     # 0xf471e
leaq 0x322fd(%rip), %rcx     # 0xf58a9
leaq 0x3102e(%rip), %r8      # 0xf45e1
movl $0xe7, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_visitor.c
// Function: csa_visitor_default_func
static int csa_visitor_default_func(GtNodeVisitor *nv, GtGenomeNode *gn,
                                    GT_UNUSED GtError *err)
{
  CSAVisitor *csa_visitor;
  gt_error_check(err);
  csa_visitor = csa_visitor_cast(nv);
  gt_queue_add(csa_visitor->gt_genome_node_buffer, gn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xc35e0
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0xc3603
callq 0xc2550
movq %rax, %rdi
movq %r14, %rsi
callq 0x2603e
movq 0x10(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5b055
movq 0x6a9ae(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6a52(%rip), %rsi      # 0xca066
leaq 0x703e(%rip), %rdx      # 0xca659
leaq 0x30fe8(%rip), %rcx     # 0xf460a
leaq 0x30fb8(%rip), %r8      # 0xf45e1
pushq $0x6f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_visitor.c
// Function: csa_visitor_save_exon
static int csa_visitor_save_exon(GtFeatureNode *fn, void *data,
                                 GT_UNUSED GtError *err)
{
  GtArray *exon_ranges = (GtArray*) data;
  GtRange range;
  gt_error_check(err);
  gt_assert(fn && exon_ranges);
  if (gt_feature_node_has_type(fn, gt_ft_exon)) {
    range = gt_genome_node_get_range((GtGenomeNode*) fn);
    gt_array_add(exon_ranges, range);
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xc3657
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0xc36cb
testq %r14, %r14
je 0xc369d
testq %rbx, %rbx
je 0xc369d
leaq 0x225b6(%rip), %rsi     # 0xe5c1e
movq %r14, %rdi
callq 0x1987b
testb %al, %al
je 0xc3693
movq %r14, %rdi
callq 0x1c3c4
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
pushq $0x10
popq %rdx
movq %rbx, %rdi
callq 0x4b801
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x6a914(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x69b8(%rip), %rsi      # 0xca066
leaq 0x310b4(%rip), %rdx     # 0xf4769
leaq 0x31097(%rip), %rcx     # 0xf4753
leaq 0x30f1e(%rip), %r8      # 0xf45e1
movl $0xd4, %r9d
jmp 0xc36f7
movq 0x6a8e6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x698a(%rip), %rsi      # 0xca066
leaq 0x6f76(%rip), %rdx      # 0xca659
leaq 0x31069(%rip), %rcx     # 0xf4753
leaq 0x30ef0(%rip), %r8      # 0xf45e1
movl $0xd3, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_get_sensitivity
double gt_evaluator_get_sensitivity(const GtEvaluator *evaluator)
{
  double sensitivity = 1.0;
  gt_assert(evaluator);
  gt_assert(evaluator->T <= evaluator->A);
  if (evaluator->A)
    sensitivity = (double) evaluator->T / evaluator->A;
  gt_assert(sensitivity >= 0.0 && sensitivity <= 1.0);
  return sensitivity;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xc389d
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
ja 0xc38c7
testq %rax, %rax
je 0xc387b
movq %rcx, %xmm1
movq 0x6c40(%rip), %xmm2     # 0xca480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x6c44(%rip), %xmm3     # 0xca490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0xc3883
movsd 0x706d(%rip), %xmm0     # 0xca8f0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc38f1
movsd 0x705b(%rip), %xmm1     # 0xca8f0
ucomisd %xmm0, %xmm1
jb 0xc38f1
popq %rax
retq
movq 0x6a714(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x67b8(%rip), %rsi      # 0xca066
leaq 0x1b724(%rip), %rdx     # 0xdefd9
leaq 0x31209(%rip), %rcx     # 0xf4ac5
leaq 0x31165(%rip), %r8      # 0xf4a28
pushq $0x39
jmp 0xc3919
movq 0x6a6ea(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x678e(%rip), %rsi      # 0xca066
leaq 0x31203(%rip), %rdx     # 0xf4ae2
leaq 0x311df(%rip), %rcx     # 0xf4ac5
leaq 0x3113b(%rip), %r8      # 0xf4a28
pushq $0x3a
jmp 0xc3919
movq 0x6a6c0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6764(%rip), %rsi      # 0xca066
leaq 0x311f6(%rip), %rdx     # 0xf4aff
leaq 0x311b5(%rip), %rcx     # 0xf4ac5
leaq 0x31111(%rip), %r8      # 0xf4a28
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_get_specificity
double gt_evaluator_get_specificity(const GtEvaluator *evaluator)
{
  double specificity = 1.0;
  gt_assert(evaluator);
  gt_assert(evaluator->T <= evaluator->P);
  if (evaluator->P)
    specificity = (double) evaluator->T / evaluator->P;
  gt_assert(specificity >= 0.0 && specificity <= 1.0);
  return specificity;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xc39ac
movq (%rdi), %rcx
movq 0x10(%rdi), %rax
cmpq %rax, %rcx
ja 0xc39d6
testq %rax, %rax
je 0xc398a
movq %rcx, %xmm1
movq 0x6b31(%rip), %xmm2     # 0xca480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x6b35(%rip), %xmm3     # 0xca490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rax, %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
jmp 0xc3992
movsd 0x6f5e(%rip), %xmm0     # 0xca8f0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xc3a00
movsd 0x6f4c(%rip), %xmm1     # 0xca8f0
ucomisd %xmm0, %xmm1
jb 0xc3a00
popq %rax
retq
movq 0x6a605(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x66a9(%rip), %rsi      # 0xca066
leaq 0x1b615(%rip), %rdx     # 0xdefd9
leaq 0x3115d(%rip), %rcx     # 0xf4b28
leaq 0x31056(%rip), %r8      # 0xf4a28
pushq $0x44
jmp 0xc3a28
movq 0x6a5db(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x667f(%rip), %rsi      # 0xca066
leaq 0x31157(%rip), %rdx     # 0xf4b45
leaq 0x31133(%rip), %rcx     # 0xf4b28
leaq 0x3102c(%rip), %r8      # 0xf4a28
pushq $0x45
jmp 0xc3a28
movq 0x6a5b1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6655(%rip), %rsi      # 0xca066
leaq 0x3114a(%rip), %rdx     # 0xf4b62
leaq 0x31109(%rip), %rcx     # 0xf4b28
leaq 0x31002(%rip), %r8      # 0xf4a28
pushq $0x48
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_show_sensitivity
void gt_evaluator_show_sensitivity(const GtEvaluator *evaluator, GtFile *outfp)
{
  gt_assert(evaluator);
  gt_file_xprintf(outfp, "%6.2f%% ("GT_WU"/"GT_WU")",
                  gt_evaluator_get_sensitivity(evaluator) * 100.0,
                  evaluator->T, evaluator->A);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc3a71
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc3818
mulsd 0x10d0e(%rip), %xmm0    # 0xd4760
movq (%r14), %rdx
movq 0x8(%r14), %rcx
leaq 0x31149(%rip), %rsi     # 0xf4ba9
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x542da
movq 0x6a540(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x65e4(%rip), %rsi      # 0xca066
leaq 0x1b550(%rip), %rdx     # 0xdefd9
leaq 0x310fb(%rip), %rcx     # 0xf4b8b
leaq 0x30f91(%rip), %r8      # 0xf4a28
pushq $0x4e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/evaluator.c
// Function: gt_evaluator_show_specificity
void gt_evaluator_show_specificity(const GtEvaluator *evaluator, GtFile *outfp)
{
  gt_assert(evaluator);
  gt_file_xprintf(outfp, "%6.2f%% ("GT_WU"/"GT_WU")",
                  gt_evaluator_get_specificity(evaluator) * 100.0,
                  evaluator->T, evaluator->P);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc3ae2
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc3927
mulsd 0x10c9d(%rip), %xmm0    # 0xd4760
movq (%r14), %rdx
movq 0x10(%r14), %rcx
leaq 0x310d8(%rip), %rsi     # 0xf4ba9
movq %rbx, %rdi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x542da
movq 0x6a4cf(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6573(%rip), %rsi      # 0xca066
leaq 0x1b4df(%rip), %rdx     # 0xdefd9
leaq 0x310ba(%rip), %rcx     # 0xf4bbb
leaq 0x30f20(%rip), %r8      # 0xf4a28
pushq $0x56
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/gff3_out_stream.c
// Function: gt_gff3_out_stream_class
const GtNodeStreamClass* gt_gff3_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtGFF3OutStream),
                                   gff3_out_stream_free,
                                   gff3_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x4f21f
cmpq $0x0, 0x6b942(%rip)     # 0x12fda0
jne 0xc447d
leaq 0x24(%rip), %rsi        # 0xc448b
leaq 0x47(%rip), %rdx        # 0xc44b5
pushq $0x20
popq %rdi
callq 0x25a78
movq %rax, 0x6b923(%rip)     # 0x12fda0
callq 0x4f266
movq 0x6b917(%rip), %rax     # 0x12fda0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/gff3_out_stream.c
// Function: gff3_out_stream_next
static int gff3_out_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                GtError *err)
{
  GtGFF3OutStream *gff3_out_stream;
  int had_err;
  gt_error_check(err);
  gff3_out_stream = gff3_out_stream_cast(ns);
  had_err = gt_node_stream_next(gff3_out_stream->in_stream, gn, err);
  if (!had_err && *gn)
    had_err = gt_genome_node_accept(*gn, gff3_out_stream->gff3_visitor, err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xc44d4
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0xc451d
callq 0xc4450
movq %rax, %rdi
movq %r15, %rsi
callq 0x25ec1
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x25c62
testl %eax, %eax
je 0xc4500
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rdi
testq %rdi, %rdi
je 0xc4519
movq 0x18(%r15), %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1c56c
xorl %eax, %eax
jmp 0xc44fa
movq 0x69a94(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5b38(%rip), %rsi      # 0xca066
leaq 0x6124(%rip), %rdx      # 0xca659
leaq 0x3091b(%rip), %rcx     # 0xf4e57
leaq 0x308cd(%rip), %r8      # 0xf4e10
pushq $0x27
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/gff3_out_stream.c
// Function: gt_gff3_out_stream_new
GtNodeStream* gt_gff3_out_stream_new(GtNodeStream *in_stream, GtFile *outfp)
{
  GtNodeStream *ns = gt_node_stream_create(gt_gff3_out_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtGFF3OutStream *gff3_out_stream = gff3_out_stream_cast(ns);
  gff3_out_stream->in_stream = gt_node_stream_ref(in_stream);
  gff3_out_stream->gff3_visitor = gt_gff3_visitor_new(outfp);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc4450
movq %rax, %r15
movq %r14, %rdi
callq 0x25e7d
movzbl %al, %esi
movq %r15, %rdi
callq 0x25adf
movq %rax, %r15
callq 0xc4450
movq %rax, %rdi
movq %r15, %rsi
callq 0x25ec1
movq %rax, %r12
movq %r14, %rdi
callq 0x25b74
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x24161
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_new
Splicedseq* gt_splicedseq_new(void)
{
  Splicedseq *ss = gt_malloc(sizeof (Splicedseq));
  ss->splicedseq = gt_str_new();
  ss->positionmapping = gt_array_new(sizeof (GtUword));
  ss->forward = true;
  return ss;
}

// Assembly:
pushq %rbx
leaq 0x3081c(%rip), %rsi     # 0xf4e6c
pushq $0x18
popq %rdi
pushq $0x22
popq %rdx
callq 0xccb0
movq %rax, %rbx
callq 0x13d5c
movq %rax, (%rbx)
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x8(%rbx)
movb $0x1, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_add
void gt_splicedseq_add(Splicedseq *ss, GtUword start, GtUword end,
                       const char *original_sequence)
{
  GtUword i;
  gt_assert(ss && start <= end && original_sequence);
  gt_str_append_cstr_nt(ss->splicedseq, original_sequence,
                        end - start + 1);
  /* make sure elements are added in ascending order */
  gt_assert(!gt_array_size(ss->positionmapping) ||
            start > *(GtUword*) gt_array_get_last(ss->positionmapping));
  for (i = start; i <= end; i++)
    gt_array_add(ss->positionmapping, i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xc472a
movq %rdx, %rbx
movq %rsi, %r15
subq %rsi, %rdx
jb 0xc472a
testq %rcx, %rcx
je 0xc472a
movq %rdi, %r14
movq (%rdi), %rdi
incq %rdx
movq %rcx, %rsi
callq 0x13f76
movq 0x8(%r14), %rdi
callq 0x4b988
testq %rax, %rax
je 0xc4716
movq 0x8(%r14), %rdi
callq 0x4b4e3
cmpq %r15, (%rax)
jb 0xc4716
movq 0x698df(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5983(%rip), %rsi      # 0xca066
leaq 0x307d6(%rip), %rdx     # 0xf4ec0
leaq 0x307bd(%rip), %rcx     # 0xf4eae
leaq 0x30774(%rip), %r8      # 0xf4e6c
pushq $0x32
jmp 0xc4752
movq 0x8(%r14), %rdi
leaq 0x8(%rsp), %r15
pushq $0x8
popq %rdx
movq %r15, %rsi
callq 0x4b801
movq (%r15), %r15
incq %r15
movq %r15, 0x8(%rsp)
cmpq %rbx, %r15
jbe 0xc46fc
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x69887(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x592b(%rip), %rsi      # 0xca066
leaq 0x30744(%rip), %rdx     # 0xf4e86
leaq 0x30765(%rip), %rcx     # 0xf4eae
leaq 0x3071c(%rip), %r8      # 0xf4e6c
pushq $0x2d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_pos_is_border
bool gt_splicedseq_pos_is_border(const Splicedseq *ss, GtUword pos)
{
  gt_assert(ss &&
         gt_str_length(ss->splicedseq) == gt_array_size(ss->positionmapping));
  gt_assert(pos < gt_str_length(ss->splicedseq)); /* legal position */
  if (ss->forward && pos + 1 < gt_array_size(ss->positionmapping) &&
      *(GtUword*) gt_array_get(ss->positionmapping, pos) + 1 !=
      *(GtUword*) gt_array_get(ss->positionmapping, pos+1)) {
    return true;
  }
  if (!ss->forward && pos &&
      *(GtUword*) gt_array_get(ss->positionmapping, pos-1) - 1 !=
      *(GtUword*) gt_array_get(ss->positionmapping, pos)) {
    return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc4831
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x14461
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x4b988
cmpq %rax, %r15
jne 0xc4831
movq (%r14), %rdi
callq 0x14461
cmpq %rbx, %rax
jbe 0xc485b
cmpb $0x1, 0x10(%r14)
jne 0xc47ee
leaq 0x1(%rbx), %r15
movq 0x8(%r14), %rdi
callq 0x4b988
cmpq %rax, %r15
jae 0xc47ee
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x4b48e
movq (%rax), %r12
incq %r12
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x4b48e
movq %rax, %rcx
movb $0x1, %al
cmpq (%rcx), %r12
jne 0xc4825
testq %rbx, %rbx
je 0xc4823
cmpb $0x0, 0x10(%r14)
jne 0xc4823
movq 0x8(%r14), %rdi
leaq -0x1(%rbx), %rsi
callq 0x4b48e
movq (%rax), %r15
decq %r15
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x4b48e
movq %rax, %rcx
movb $0x1, %al
cmpq (%rcx), %r15
jne 0xc4825
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x69780(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5824(%rip), %rsi      # 0xca066
leaq 0x306d9(%rip), %rdx     # 0xf4f22
leaq 0x3071c(%rip), %rcx     # 0xf4f6c
leaq 0x30615(%rip), %r8      # 0xf4e6c
pushq $0x3f
jmp 0xc4883
movq 0x69756(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x57fa(%rip), %rsi      # 0xca066
leaq 0x30715(%rip), %rdx     # 0xf4f88
leaq 0x306f2(%rip), %rcx     # 0xf4f6c
leaq 0x305eb(%rip), %r8      # 0xf4e6c
pushq $0x40
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_map
GtUword gt_splicedseq_map(const Splicedseq *ss, GtUword pos)
{
  gt_assert(ss &&
         gt_str_length(ss->splicedseq) == gt_array_size(ss->positionmapping));
  gt_assert(pos < gt_str_length(ss->splicedseq)); /* legal position */
  return *(GtUword*) gt_array_get(ss->positionmapping, pos);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xc48dc
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x14461
movq %rax, %r15
movq 0x8(%r14), %rdi
callq 0x4b988
cmpq %rax, %r15
jne 0xc48dc
movq (%r14), %rdi
callq 0x14461
cmpq %rbx, %rax
jbe 0xc4906
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x4b48e
movq (%rax), %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x696d5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5779(%rip), %rsi      # 0xca066
leaq 0x3062e(%rip), %rdx     # 0xf4f22
leaq 0x306b1(%rip), %rcx     # 0xf4fac
leaq 0x3056a(%rip), %r8      # 0xf4e6c
pushq $0x51
jmp 0xc492e
movq 0x696ab(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x574f(%rip), %rsi      # 0xca066
leaq 0x3066a(%rip), %rdx     # 0xf4f88
leaq 0x30687(%rip), %rcx     # 0xf4fac
leaq 0x30540(%rip), %r8      # 0xf4e6c
pushq $0x52
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_reverse
int gt_splicedseq_reverse(Splicedseq *ss, GtError *err)
{
  int had_err;
  gt_error_check(err);
  gt_assert(ss);
  had_err = gt_reverse_complement(gt_str_get(ss->splicedseq),
                               gt_str_length(ss->splicedseq), err);
  if (!had_err) {
    gt_array_reverse(ss->positionmapping);
    ss->forward = !ss->forward;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0xc499e
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0xc4a0e
testq %rbx, %rbx
je 0xc49e4
movq (%rbx), %rdi
callq 0x143d2
movq %rax, %r15
movq (%rbx), %rdi
callq 0x14461
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x8a514
movl %eax, %ebp
testl %eax, %eax
jne 0xc49d7
movq 0x8(%rbx), %rdi
callq 0x4b6dd
xorb $0x1, 0x10(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x695cd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5671(%rip), %rsi      # 0xca066
leaq 0xb63e(%rip), %rdx      # 0xd003a
leaq 0x305d0(%rip), %rcx     # 0xf4fd3
leaq 0x30462(%rip), %r8      # 0xf4e6c
pushq $0x60
jmp 0xc4a36
movq 0x695a3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5647(%rip), %rsi      # 0xca066
leaq 0x5c33(%rip), %rdx      # 0xca659
leaq 0x305a6(%rip), %rcx     # 0xf4fd3
leaq 0x30438(%rip), %r8      # 0xf4e6c
pushq $0x5f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_reset
void gt_splicedseq_reset(Splicedseq *ss)
{
  gt_assert(ss);
  gt_str_reset(ss->splicedseq);
  gt_array_reset(ss->positionmapping);
  ss->forward = true;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xc4a64
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1452f
movq 0x8(%rbx), %rdi
callq 0x4ba50
movb $0x1, 0x10(%rbx)
popq %rbx
retq
movq 0x6954d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x55f1(%rip), %rsi      # 0xca066
leaq 0xb5be(%rip), %rdx      # 0xd003a
leaq 0x30566(%rip), %rcx     # 0xf4fe9
leaq 0x303e2(%rip), %r8      # 0xf4e6c
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_unit_test
int gt_splicedseq_unit_test(GtError *err)
{
  Splicedseq *ss;
  int had_err = 0;
  gt_error_check(err);
  ss = gt_splicedseq_new();
  had_err = check_splicedseq(ss, err);
  if (!had_err) {
    gt_splicedseq_reset(ss);
    had_err = check_splicedseq(ss, err);
  }
  gt_splicedseq_delete(ss);
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0xc4ab2
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0xc4af5
callq 0xc4648
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xc4b2d
testl %eax, %eax
je 0xc4ace
pushq $-0x1
popq %rbx
jmp 0xc4ae3
movq %r14, %rdi
callq 0xc4a44
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc4b2d
movl %eax, %ebx
movq %r14, %rdi
callq 0xc4ced
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x694bc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5560(%rip), %rsi      # 0xca066
leaq 0x5b4c(%rip), %rdx      # 0xca659
leaq 0x304e9(%rip), %rcx     # 0xf4ffd
leaq 0x30351(%rip), %r8      # 0xf4e6c
movl $0x86, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/splicedseq.c
// Function: check_splicedseq
static int check_splicedseq(Splicedseq *ss, GtError *err)
{                       /*0123456789*/
  static char *origseq = "aaccaagtga", *splicedseq = "ccgtg";
  int had_err = 0;
  gt_error_check(err);
  gt_splicedseq_add(ss, 2, 3, origseq + 2);
  gt_splicedseq_add(ss, 6, 8, origseq + 6);
  gt_ensure(strcmp(gt_splicedseq_get(ss), splicedseq) == 0);
  gt_ensure(!gt_splicedseq_pos_is_border(ss, 0));
  gt_ensure(gt_splicedseq_pos_is_border(ss, 1));
  gt_ensure(!gt_splicedseq_pos_is_border(ss, 2));
  gt_ensure(!gt_splicedseq_pos_is_border(ss, 3));
  gt_ensure(!gt_splicedseq_pos_is_border(ss, 4));
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xc4b4c
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0xc4cb7
leaq 0x304c4(%rip), %rcx     # 0xf5017
pushq $0x2
popq %rsi
pushq $0x3
popq %rdx
movq %r14, %rdi
callq 0xc467b
leaq 0x304b3(%rip), %rcx     # 0xf501b
pushq $0x6
popq %rsi
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0xc467b
movq %r14, %rdi
callq 0xc4760
leaq 0x3049b(%rip), %rsi     # 0xf5020
movq %rax, %rdi
callq 0xb880
testl %eax, %eax
je 0xc4bb4
leaq 0x75c1(%rip), %rsi      # 0xcc159
leaq 0x30498(%rip), %rdx     # 0xf5037
leaq 0x30480(%rip), %rcx     # 0xf5026
leaq 0x302bf(%rip), %r8      # 0xf4e6c
pushq $0x79
jmp 0xc4c3e
movq %r14, %rdi
xorl %esi, %esi
callq 0xc4768
testb %al, %al
je 0xc4be2
leaq 0x7590(%rip), %rsi      # 0xcc159
leaq 0x30496(%rip), %rdx     # 0xf5066
leaq 0x3044f(%rip), %rcx     # 0xf5026
leaq 0x3028e(%rip), %r8      # 0xf4e6c
pushq $0x7a
jmp 0xc4c3e
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xc4768
testb %al, %al
je 0xc4c20
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0xc4768
testb %al, %al
je 0xc4c55
leaq 0x7552(%rip), %rsi      # 0xcc159
leaq 0x3049f(%rip), %rdx     # 0xf50ad
leaq 0x30411(%rip), %rcx     # 0xf5026
leaq 0x30250(%rip), %r8      # 0xf4e6c
pushq $0x7c
jmp 0xc4c3e
leaq 0x7532(%rip), %rsi      # 0xcc159
leaq 0x3045c(%rip), %rdx     # 0xf508a
leaq 0x303f1(%rip), %rcx     # 0xf5026
leaq 0x30230(%rip), %r8      # 0xf4e6c
pushq $0x7b
popq %r9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0xc4768
testb %al, %al
je 0xc4c84
leaq 0x74ee(%rip), %rsi      # 0xcc159
leaq 0x3045f(%rip), %rdx     # 0xf50d1
leaq 0x303ad(%rip), %rcx     # 0xf5026
leaq 0x301ec(%rip), %r8      # 0xf4e6c
pushq $0x7d
jmp 0xc4c3e
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0xc4768
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xc4c4d
leaq 0x74bb(%rip), %rsi      # 0xcc159
leaq 0x30450(%rip), %rdx     # 0xf50f5
leaq 0x3037a(%rip), %rcx     # 0xf5026
leaq 0x301b9(%rip), %r8      # 0xf4e6c
pushq $0x7e
jmp 0xc4c3e
movq 0x692fa(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x539e(%rip), %rsi      # 0xca066
leaq 0x598a(%rip), %rdx      # 0xca659
leaq 0x30350(%rip), %rcx     # 0xf5026
leaq 0x3018f(%rip), %r8      # 0xf4e6c
pushq $0x76
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/splicedseq.c
// Function: gt_splicedseq_delete
void gt_splicedseq_delete(Splicedseq *ss)
{
  if (!ss) return;
  gt_str_delete(ss->splicedseq);
  gt_array_delete(ss->positionmapping);
  gt_free(ss);
}

// Assembly:
testq %rdi, %rdi
je 0xc4d1c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x152db
movq 0x8(%rbx), %rdi
callq 0x4c19d
leaq 0x3015e(%rip), %rsi     # 0xf4e6c
movq %rbx, %rdi
movl $0x96, %edx
popq %rbx
jmp 0xd249
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/bzip2-1.0.6/huffman.c
// Function: BZ2_hbAssignCodes
void BZ2_hbAssignCodes ( Int32 *code,
                         UChar *length,
                         Int32 minLen,
                         Int32 maxLen,
                         Int32 alphaSize )
{
   Int32 n, vec, i;

   vec = 0;
   for (n = minLen; n <= maxLen; n++) {
      for (i = 0; i < alphaSize; i++)
         if (length[i] == n) { code[i] = vec; vec++; };
      vec <<= 1;
   }
}

// Assembly:
xorl %eax, %eax
testl %r8d, %r8d
cmovlel %eax, %r8d
cmpl %ecx, %edx
jg 0xc6a23
xorl %r9d, %r9d
cmpq %r9, %r8
je 0xc6a1d
movzbl (%rsi,%r9), %r10d
cmpl %r10d, %edx
jne 0xc6a18
movl %eax, (%rdi,%r9,4)
incl %eax
incq %r9
jmp 0xc6a03
addl %eax, %eax
incl %edx
jmp 0xc69fc
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/bzip2-1.0.6/huffman.c
// Function: BZ2_hbCreateDecodeTables
void BZ2_hbCreateDecodeTables ( Int32 *limit,
                                Int32 *base,
                                Int32 *perm,
                                UChar *length,
                                Int32 minLen,
                                Int32 maxLen,
                                Int32 alphaSize )
{
   Int32 pp, i, j, vec;

   pp = 0;
   for (i = minLen; i <= maxLen; i++)
      for (j = 0; j < alphaSize; j++)
         if (length[j] == i) { perm[pp] = j; pp++; };

   for (i = 0; i < BZ_MAX_CODE_LEN; i++) base[i] = 0;
   for (i = 0; i < alphaSize; i++) base[length[i]+1]++;

   for (i = 1; i < BZ_MAX_CODE_LEN; i++) base[i] += base[i-1];

   for (i = 0; i < BZ_MAX_CODE_LEN; i++) limit[i] = 0;
   vec = 0;

   for (i = minLen; i <= maxLen; i++) {
      vec += (base[i+1] - base[i]);
      limit[i] = vec-1;
      vec <<= 1;
   }
   for (i = minLen + 1; i <= maxLen; i++)
      base[i] = ((limit[i-1] + 1) << 1) - base[i];
}

// Assembly:
pushq %rbp
pushq %rbx
movl 0x18(%rsp), %eax
xorl %r10d, %r10d
testl %eax, %eax
cmovlel %r10d, %eax
movl %r8d, %r11d
cmpl %r9d, %r11d
jg 0xc6a5f
xorl %ebx, %ebx
cmpq %rbx, %rax
je 0xc6a5a
movzbl (%rcx,%rbx), %ebp
cmpl %ebp, %r11d
jne 0xc6a55
movslq %r10d, %r10
movl %ebx, (%rdx,%r10,4)
incl %r10d
incq %rbx
jmp 0xc6a3d
incl %r11d
jmp 0xc6a36
xorl %edx, %edx
cmpq $0x17, %rdx
je 0xc6a70
andl $0x0, (%rsi,%rdx,4)
incq %rdx
jmp 0xc6a61
xorl %edx, %edx
cmpq %rdx, %rax
je 0xc6a86
movzbl (%rcx,%rdx), %r10d
incl 0x4(%rsi,%r10,4)
incq %rdx
jmp 0xc6a72
movabsq $0x1, %rax
cmpq $0x17, %rax
je 0xc6aa2
movl -0x4(%rsi,%rax,4), %ecx
addl %ecx, (%rsi,%rax,4)
incq %rax
jmp 0xc6a90
xorl %eax, %eax
cmpq $0x17, %rax
je 0xc6ab3
andl $0x0, (%rdi,%rax,4)
incq %rax
jmp 0xc6aa4
movslq %r8d, %rcx
movslq %r9d, %rax
xorl %edx, %edx
movq %rcx, %r8
cmpq %rax, %r8
jg 0xc6af4
movl 0x4(%rsi,%r8,4), %r9d
subl (%rsi,%r8,4), %r9d
leal (%r9,%rdx), %r10d
decl %r10d
movl %r10d, (%rdi,%r8,4)
incq %r8
addl %r9d, %edx
addl %edx, %edx
jmp 0xc6abe
movl (%rdi,%rcx,4), %edx
addl %edx, %edx
subl 0x4(%rsi,%rcx,4), %edx
addl $0x2, %edx
movl %edx, 0x4(%rsi,%rcx,4)
incq %rcx
cmpq %rax, %rcx
jl 0xc6ae1
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/bitpackstringop32.c
// Function: gt_bsGetUInt32
uint32_t
gt_bsGetUInt32(constBitString str, BitOffset offset, unsigned numBits)
{
  GtUword accum = 0;
  unsigned bitsLeft = numBits, bitTop = offset%bitElemBits;
  size_t elemStart = offset/bitElemBits;
  const BitElem *p = str + elemStart;
  gt_assert(str);
#ifndef NDEBUG
  if (numBits > sizeof (accum)*CHAR_BIT)
    fprintf(stderr, "numBits = %u\n", numBits);
#endif
  gt_assert(numBits <= sizeof (accum)*CHAR_BIT);
  if (bitTop)
  {
    GtUword mask;
    unsigned bits2Read = GT_MIN(bitElemBits - bitTop, bitsLeft);
    unsigned unreadRightBits = (bitElemBits - bitTop - bits2Read);
    mask = (~((~(GtUword)0) << bits2Read)) << unreadRightBits;
    accum = ((*p++) & mask) >> unreadRightBits;
    bitsLeft -= bits2Read;
  }
  /* get bits from intervening elems */
  while (bitsLeft >= bitElemBits)
  {
    accum = accum << bitElemBits | (*p++);
    bitsLeft -= bitElemBits;
  }
  /* get bits from last elem */
  if (bitsLeft)
  {
    accum = accum << bitsLeft |
      (((*p) & ((~(GtUword)0)<<(bitElemBits - bitsLeft)))
       >>(bitElemBits - bitsLeft));
  }
  return accum;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xc6b8b
cmpl $0x41, %edx
jae 0xc6bb5
movl %esi, %eax
andl $0x7, %eax
shrq $0x3, %rsi
addq %rsi, %rdi
testl %eax, %eax
je 0xc6b51
pushq $0x8
popq %rsi
subl %eax, %esi
cmpl %edx, %esi
movl %edx, %r8d
cmovbl %esi, %r8d
subl %r8d, %esi
pushq $-0x1
popq %rax
movl %r8d, %ecx
shll %cl, %eax
notl %eax
movl %esi, %ecx
shlq %cl, %rax
movzbl (%rdi), %ecx
incq %rdi
andl %ecx, %eax
movl %esi, %ecx
shrq %cl, %rax
subl %r8d, %edx
jmp 0xc6b53
xorl %eax, %eax
movl %edx, %ecx
cmpl $0x8, %ecx
jb 0xc6b6d
shlq $0x8, %rax
movzbl (%rdi), %edx
incq %rdi
orq %rdx, %rax
addq $-0x8, %rcx
jmp 0xc6b55
testl %ecx, %ecx
je 0xc6b89
shlq %cl, %rax
movzbl (%rdi), %esi
movb $0x8, %dl
subb %cl, %dl
movl %edx, %ecx
shrq %cl, %rsi
shlq %cl, %rsi
shrq %cl, %rsi
orq %rsi, %rax
popq %rbx
retq
movq 0x67426(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34ca(%rip), %rsi      # 0xca066
leaq 0x5e10(%rip), %rdx      # 0xcc9b3
leaq 0x2e6ee(%rip), %rcx     # 0xf5298
leaq 0x2e6f6(%rip), %r8      # 0xf52a7
pushq $0x22
jmp 0xc6bee
movq 0x673fc(%rip), %rbx     # 0x12dfb8
movq (%rbx), %rdi
leaq 0x2e6fe(%rip), %rsi     # 0xf52c4
xorl %eax, %eax
callq 0xb8c0
movq (%rbx), %rdi
leaq 0x348f(%rip), %rsi      # 0xca066
leaq 0x2e6f4(%rip), %rdx     # 0xf52d2
leaq 0x2e6b3(%rip), %rcx     # 0xf5298
leaq 0x2e6bb(%rip), %r8      # 0xf52a7
pushq $0x27
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/md5_fingerprint.c
// Function: gt_md5_fingerprint
char* gt_md5_fingerprint(const char *sequence, GtUword seqlen)
{
  unsigned char output[16];
  char buf[64];
  char *fingerprint;
  GtMD5Encoder *enc;
  GtUword i, pos = 0;

  enc = gt_md5_encoder_new();
  for (i = 0; i < seqlen; i++) {
    if (pos == 64) {
      gt_md5_encoder_add_block(enc, buf, 64);
      pos = 0;
    }
    buf[pos++] = toupper(sequence[i]);
  }
  gt_md5_encoder_add_block(enc, buf, pos);
  fingerprint = gt_calloc(33, sizeof (char));
  gt_md5_encoder_finish(enc, output, fingerprint);

  gt_md5_encoder_delete(enc);
  return fingerprint;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
callq 0xbe778
movq %rax, %rbx
pushq $0x40
popq %rbp
xorl %r13d, %r13d
cmpq %r13, %r14
je 0xc8084
cmpq $0x40, %r12
jne 0xc8067
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
movq %rbp, %rdx
callq 0xbe818
xorl %r12d, %r12d
callq 0xb0b0
movq (%rax), %rax
movsbq (%r15,%r13), %rcx
movb (%rax,%rcx,4), %al
movb %al, 0x10(%rsp,%r12)
incq %r12
incq %r13
jmp 0xc8049
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0xbe818
leaq 0x2d407(%rip), %rdx     # 0xf54a2
pushq $0x21
popq %rdi
pushq $0x1
popq %rsi
pushq $0x2b
popq %rcx
callq 0xce9a
movq %rax, %r14
movq %rsp, %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0xbec13
movq %rbx, %rdi
callq 0xbee0d
movq %r14, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_gene.c
// Function: gt_csa_gene_new
GtCSAGene* gt_csa_gene_new(GtCSASpliceForm *splice_form)
{
  GtCSAGene *gene;
  gt_assert(splice_form);
  gene = gt_malloc(sizeof *gene);
  gene->splice_forms = gt_array_new(sizeof (GtCSASpliceForm*));
  gt_array_add(gene->splice_forms, splice_form);
  return gene;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0xc82c5
leaq 0x2d286(%rip), %rsi     # 0xf5516
pushq $0x8
popq %rbx
pushq $0x1d
popq %rdx
movq %rbx, %rdi
callq 0xccb0
movq %rax, %r14
movq %rbx, %rdi
callq 0x4b380
movq %rax, (%r14)
movq %rsp, %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x4b801
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x65cec(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1d90(%rip), %rsi      # 0xca066
leaq 0x2d259(%rip), %rdx     # 0xf5536
leaq 0x2d222(%rip), %rcx     # 0xf5506
leaq 0x2d22b(%rip), %r8      # 0xf5516
pushq $0x1c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_gene.c
// Function: gt_csa_gene_delete
void gt_csa_gene_delete(GtCSAGene *gene)
{
  GtUword i;
  if (!gene) return;
  for (i = 0; i < gt_array_size(gene->splice_forms); i++) {
    gt_csa_splice_form_delete(*(GtCSASpliceForm**)
                              gt_array_get(gene->splice_forms, i));
  }
  gt_array_delete(gene->splice_forms);
  gt_free(gene);
}

// Assembly:
testq %rdi, %rdi
je 0xc834d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x4b988
movq (%rbx), %rdi
cmpq %rax, %r14
jae 0xc832f
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0xc865f
incq %r14
jmp 0xc830a
callq 0x4c19d
leaq 0x2d1db(%rip), %rsi     # 0xf5516
pushq $0x2c
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_gene.c
// Function: gt_csa_gene_add_splice_form
void gt_csa_gene_add_splice_form(GtCSAGene *gene, GtCSASpliceForm *splice_form)
{
  gt_assert(gene && splice_form);
  gt_assert(gt_csa_splice_form_strand(*(GtCSASpliceForm**)
                                gt_array_get(gene->splice_forms, 0)) ==
         gt_csa_splice_form_strand(splice_form));
  gt_array_add(gene->splice_forms, splice_form);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0xc83a4
movq %rsi, %r14
testq %rsi, %rsi
je 0xc83a4
movq %rdi, %rbx
movq (%rdi), %rdi
xorl %esi, %esi
callq 0x4b48e
movq (%rax), %rdi
callq 0xc8773
movl %eax, %ebp
movq %r14, %rdi
callq 0xc8773
cmpl %eax, %ebp
jne 0xc83ce
movq (%rbx), %rdi
leaq 0x8(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0x4b801
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x65c0d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1cb1(%rip), %rsi      # 0xca066
leaq 0x2d172(%rip), %rdx     # 0xf552e
leaq 0x2d17f(%rip), %rcx     # 0xf5542
leaq 0x2d14c(%rip), %r8      # 0xf5516
pushq $0x31
jmp 0xc83f6
movq 0x65be3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1c87(%rip), %rsi      # 0xca066
leaq 0x2d178(%rip), %rdx     # 0xf555e
leaq 0x2d155(%rip), %rcx     # 0xf5542
leaq 0x2d122(%rip), %r8      # 0xf5516
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_gene.c
// Function: gt_csa_gene_genomic_range
GtRange gt_csa_gene_genomic_range(const GtCSAGene *gene)
{
  GtRange gene_range, tmp_range;
  GtUword i;
  gt_assert(gene);
  gene_range.start = ~0UL;
  gene_range.end = 0UL;
  for (i = 0; i < gt_array_size(gene->splice_forms); i++) {
    tmp_range = gt_csa_splice_form_genomic_range(*(GtCSASpliceForm**)
                                              gt_array_get(gene->splice_forms,
                                                           i));
    if (tmp_range.start < gene_range.start)
      gene_range.start = tmp_range.start;
    if (tmp_range.end > gene_range.end)
      gene_range.end = tmp_range.end;
  }
  return gene_range;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc84f0
movq %rdi, %rbx
pushq $-0x1
popq %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rdi
callq 0x4b988
cmpq %rax, %r15
jae 0xc84de
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0xc8856
cmpq %r14, %rax
cmovbq %rax, %r14
cmpq %r12, %rdx
cmovaq %rdx, %r12
incq %r15
jmp 0xc84ab
movq %r14, %rax
movq %r12, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x65ac1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1b65(%rip), %rsi      # 0xca066
leaq 0x2d448(%rip), %rdx     # 0xf5950
leaq 0x2d109(%rip), %rcx     # 0xf5618
leaq 0x2d000(%rip), %r8      # 0xf5516
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_gene.c
// Function: gt_csa_gene_get_representative
void* gt_csa_gene_get_representative(const GtCSAGene *gene)
{
  gt_assert(gene);
  return gt_csa_splice_form_get_representative(*(GtCSASpliceForm**)
                                            gt_array_get(gene->splice_forms,
                                                         0));
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xc858e
movq (%rdi), %rdi
xorl %esi, %esi
callq 0x4b48e
movq (%rax), %rdi
popq %rax
jmp 0xc88ec
movq 0x65a23(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1ac7(%rip), %rsi      # 0xca066
leaq 0x2d3aa(%rip), %rdx     # 0xf5950
leaq 0x2d098(%rip), %rcx     # 0xf5645
leaq 0x2cf62(%rip), %r8      # 0xf5516
pushq $0x61
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_splice_form.c
// Function: gt_csa_splice_form_new
GtCSASpliceForm* gt_csa_splice_form_new(void *spliced_alignment,
                                   GtGetGenomicRangeFunc get_genomic_range,
                                   GtGetStrandFunc get_strand)
{
  GtCSASpliceForm *splice_form;
  gt_assert(spliced_alignment && get_strand);
  splice_form = gt_malloc(sizeof (*splice_form));
  splice_form->spliced_alignments = gt_array_new(sizeof (void*));
  gt_array_add(splice_form->spliced_alignments, spliced_alignment);
  splice_form->get_genomic_range = get_genomic_range;
  splice_form->get_strand = get_strand;
  return splice_form;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0xc8629
movq %rdx, %rbx
testq %rdx, %rdx
je 0xc8629
movq %rsi, %r14
leaq 0x2d0b4(%rip), %rsi     # 0xf569b
pushq $0x18
popq %rdi
pushq $0x22
popq %rdx
callq 0xccb0
movq %rax, %r15
pushq $0x8
popq %r12
movq %r12, %rdi
callq 0x4b380
movq %rax, (%r15)
movq %rsp, %rsi
movq %rax, %rdi
movq %r12, %rdx
callq 0x4b801
movq %r14, 0x8(%r15)
movq %rbx, 0x10(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x65988(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1a2c(%rip), %rsi      # 0xca066
leaq 0x2d023(%rip), %rdx     # 0xf5664
leaq 0x2d03c(%rip), %rcx     # 0xf5684
leaq 0x2d04c(%rip), %r8      # 0xf569b
pushq $0x21
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_splice_form.c
// Function: gt_csa_splice_form_add_sa
void gt_csa_splice_form_add_sa(GtCSASpliceForm *splice_form,
                               void *spliced_alignment)
{
  gt_assert(splice_form);
  gt_assert(csa_splice_form_start(splice_form) <=
         splice_form->get_genomic_range(spliced_alignment).start);
  gt_assert(gt_csa_splice_form_strand(splice_form) ==
         splice_form->get_strand(spliced_alignment));
  gt_array_add(splice_form->spliced_alignments, spliced_alignment);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rdi, %rdi
je 0xc86e9
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %r15
xorl %esi, %esi
callq 0x4b48e
movq (%rax), %rdi
callq *%r15
movq %rax, %r15
movq %r14, %rdi
callq *0x8(%rbx)
cmpq %rax, %r15
ja 0xc8713
movq %rbx, %rdi
callq 0xc8773
movl %eax, %ebp
movq %r14, %rdi
callq *0x10(%rbx)
cmpl %eax, %ebp
jne 0xc873d
movq (%rbx), %rdi
movq %rsp, %rsi
pushq $0x8
popq %rdx
callq 0x4b801
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x658c8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x196c(%rip), %rsi      # 0xca066
leaq 0x2ce35(%rip), %rdx     # 0xf5536
leaq 0x2cfb2(%rip), %rcx     # 0xf56ba
leaq 0x2cf8c(%rip), %r8      # 0xf569b
pushq $0x3e
jmp 0xc8765
movq 0x6589e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1942(%rip), %rsi      # 0xca066
leaq 0x2cfa9(%rip), %rdx     # 0xf56d4
leaq 0x2cf88(%rip), %rcx     # 0xf56ba
leaq 0x2cf62(%rip), %r8      # 0xf569b
pushq $0x40
jmp 0xc8765
movq 0x65874(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x1918(%rip), %rsi      # 0xca066
leaq 0x2cfdd(%rip), %rdx     # 0xf5732
leaq 0x2cf5e(%rip), %rcx     # 0xf56ba
leaq 0x2cf38(%rip), %r8      # 0xf569b
pushq $0x42
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/csa_splice_form.c
// Function: gt_csa_splice_form_strand
GtStrand gt_csa_splice_form_strand(const GtCSASpliceForm *splice_form)
{
  gt_assert(splice_form);
  return splice_form->get_strand(*(void**)
                                 gt_array_get(splice_form->spliced_alignments,
                                              0));
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xc8793
movq (%rdi), %rax
movq 0x10(%rdi), %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x4b48e
movq (%rax), %rdi
movq %rbx, %rax
popq %rbx
jmpq *%rax
movq 0x6581e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x18c2(%rip), %rsi      # 0xca066
leaq 0x2cd8b(%rip), %rdx     # 0xf5536
leaq 0x2d02e(%rip), %rcx     # 0xf57e0
leaq 0x2cee2(%rip), %r8      # 0xf569b
pushq $0x69
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300