LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/squarealign.c
// Function: fillDPtab_in_square_space
static void fillDPtab_in_square_space(GtUword **E,
                                      const GtUchar *useq,
                                      GtUword ustart,
                                      GtUword ulen,
                                      const GtUchar *vseq,
                                      GtUword vstart,
                                      GtUword vlen,
                                      const GtScoreHandler *scorehandler)
{
  GtUword i, j, gapcost;
  gapcost =  gt_scorehandler_get_gapscore(scorehandler);

  E[0][0] = 0;
  for (i = 1; i <= ulen; i++)
  {
    E[i][0] = E[i-1][0] + gapcost;
  }
  for (j = 1; j <= vlen; j++)
  {
    E[0][j] = E[0][j-1] + gapcost;
    for (i = 1; i <= ulen; i++)
    {
      GtUword val;

      E[i][j] = E[i][j-1] + gapcost;
      val = E[i-1][j-1] + gt_scorehandler_get_replacement(scorehandler,
                                                          useq[ustart+i-1],
                                                          vseq[vstart+j-1]);
      if (val <= E[i][j])
      {
        E[i][j] = val;
      }
      if ((val = E[i-1][j] + gapcost) < E[i][j])
      {
        E[i][j] = val;
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %rbp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x58(%rsp), %rdi
callq 0x171437
movq %rax, %r13
movq (%r15), %rax
movq $0x0, (%rax)
movq %rbx, 0x8(%rsp)
testq %rbx, %rbx
je 0x179971
movq 0x8(%rsp), %rax
leaq 0x1(%rax), %rcx
cmpq $0x3, %rcx
movl $0x2, %eax
cmovaeq %rcx, %rax
movl $0x1, %ecx
movq -0x8(%r15,%rcx,8), %rdx
movq (%r15,%rcx,8), %rsi
movq (%rdx), %rdx
addq %r13, %rdx
movq %rdx, (%rsi)
incq %rcx
cmpq %rcx, %rax
jne 0x179957
cmpq $0x0, 0x50(%rsp)
je 0x179a24
addq %r14, %rbp
decq %rbp
addq %r12, 0x10(%rsp)
movl $0x1, %r12d
movq (%r15), %rax
movq -0x8(%rax,%r12,8), %rcx
addq %r13, %rcx
movq %rcx, (%rax,%r12,8)
cmpq $0x0, 0x8(%rsp)
je 0x179a16
movl $0x1, %r14d
movq (%r15,%r14,8), %rax
movq -0x8(%rax,%r12,8), %rcx
addq %r13, %rcx
movq %rcx, (%rax,%r12,8)
movq -0x8(%r15,%r14,8), %rax
movq -0x8(%rax,%r12,8), %rbx
movq 0x10(%rsp), %rax
movzbl -0x1(%rax,%r14), %esi
movzbl (%rbp,%r12), %edx
movq 0x58(%rsp), %rdi
callq 0x171466
addq %rbx, %rax
movq (%r15,%r14,8), %rcx
movq (%rcx,%r12,8), %rdx
cmpq %rdx, %rax
ja 0x1799f7
movq %rax, (%rcx,%r12,8)
movq %rax, %rdx
movq -0x8(%r15,%r14,8), %rax
movq (%rax,%r12,8), %rax
addq %r13, %rax
cmpq %rdx, %rax
jae 0x179a0c
movq %rax, (%rcx,%r12,8)
incq %r14
cmpq 0x8(%rsp), %r14
jbe 0x1799ab
incq %r12
cmpq 0x50(%rsp), %r12
jbe 0x17998e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/squarealign.c
// Function: gt_squarealign_global_distance_only
GtUword gt_squarealign_global_distance_only(const GtUchar *useq,
                                            GtUword ustart,
                                            GtUword ulen,
                                            const GtUchar *vseq,
                                            GtUword vstart,
                                            GtUword vlen,
                                            const GtScoreHandler *scorehandler)
{
  GtUword **E, distance;

  gt_assert(scorehandler);

  gt_array2dim_malloc(E, (ulen+1), (vlen+1));
  fillDPtab_in_square_space(E, useq, ustart, ulen,
                            vseq, vstart, vlen, scorehandler);
  distance = E[ulen][vlen];
  gt_array2dim_delete(E);
  return distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x179b37
movq %r9, %rbx
movq %rdx, %r14
leaq 0x1(%rdx), %r15
leaq 0x8(,%rdx,8), %r13
leaq 0x21abad(%rip), %rbp    # 0x394627
movq %r13, %rdi
movq %rbp, %rsi
movl $0x75, %edx
callq 0x104226
movq %rax, %r12
leaq 0x1(%rbx), %rdi
imulq %r13, %rdi
movq %rbp, %rsi
movl $0x75, %edx
callq 0x104226
movq %rax, (%r12)
cmpq $0x2, %r15
jb 0x179acd
leaq 0x8(,%rbx,8), %rax
movq (%r12), %rcx
addq %rax, %rcx
xorl %edx, %edx
movq %rcx, 0x8(%r12,%rdx,8)
addq %rax, %rcx
incq %rdx
cmpq %rdx, %r14
jne 0x179abd
movq %r12, %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
pushq 0x60(%rsp)
pushq %rbx
callq 0x1798f9
addq $0x10, %rsp
movq (%r12,%r14,8), %rax
movq (%rax,%rbx,8), %rbx
movq (%r12), %rdi
leaq 0x21ab1f(%rip), %r14    # 0x394627
movq %r14, %rsi
movl $0x79, %edx
callq 0x1045eb
movq %r12, %rdi
movq %r14, %rsi
movl $0x79, %edx
callq 0x1045eb
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x55d46
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/squarealign.c
// Function: gt_squarealign_calculate
GtUword gt_squarealign_calculate(GtLinspaceManagement *spacemanager,
                                 GtAlignment *align,
                                 const GtUchar *useq,
                                 GtUword ustart,
                                 GtUword ulen,
                                 const GtUchar *vseq,
                                 GtUword vstart,
                                 GtUword vlen,
                                 GtUword matchcost,
                                 GtUword mismatchcost,
                                 GtUword gapcost)
{
  GtUword distance;
  GtScoreHandler *scorehandler;

  gt_assert(align);
  scorehandler = gt_scorehandler_new(matchcost, mismatchcost, 0, gapcost);
  distance = gt_squarealign_calculate_generic (spacemanager, align,
                                               useq, ustart,  ulen,
                                               vseq,  vstart, vlen,
                                               scorehandler);
  gt_scorehandler_delete(scorehandler);
  return distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
testq %rsi, %rsi
je 0x179bbf
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0x17137c
movq %rax, %rbx
subq $0x8, %rsp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq 0x8(%rsp), %r9
pushq %rax
pushq 0x58(%rsp)
pushq 0x58(%rsp)
callq 0x179784
addq $0x20, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x1713ff
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x55d7d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/squarealign.c
// Function: gt_squarealign_print_edit_alignment
void gt_squarealign_print_edit_alignment(const GtUchar *useq, GtUword ustart,
                                         GtUword ulen, const GtUchar *vseq,
                                         GtUword vstart, GtUword vlen)
{
  GtAlignment *align;
  align = gt_alignment_new_with_seqs(useq+ustart, ulen, vseq+vstart, vlen);

  gt_squarealign_calculate(NULL, align, useq, ustart, ulen,
                           vseq, vstart, vlen, 0, 1, 1);
  gt_alignment_show(align, true, stdout, 80);
  gt_alignment_delete(align);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
addq %rsi, %rdi
leaq (%rcx,%r8), %rdx
movq %r13, %rsi
movq %r9, %rcx
callq 0x120d76
movq %rax, %r15
subq $0x8, %rsp
movl $0x1, %eax
xorl %edi, %edi
movq %r15, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
movq %r13, %r8
movq %r12, %r9
pushq %rax
pushq %rax
pushq $0x0
pushq %r14
pushq 0x28(%rsp)
callq 0x179b3c
addq $0x30, %rsp
movq 0x33f2ad(%rip), %rax    # 0x4b8ed8
movq (%rax), %rdx
movq %r15, %rdi
movl $0x1, %esi
movl $0x50, %ecx
callq 0x121bc2
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x121e3c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/squarealign.c
// Function: gt_squarealign_calculate_local
GtWord gt_squarealign_calculate_local(GtLinspaceManagement *spacemanager,
                                      GtAlignment *align,
                                      const GtUchar *useq,
                                      GtUword ustart,
                                      GtUword ulen,
                                      const GtUchar *vseq,
                                      GtUword vstart,
                                      GtUword vlen,
                                      GtWord matchscore,
                                      GtWord mismatchscore,
                                      GtWord gapscore)
{
  GtWord score;
  gt_assert(align);
  GtScoreHandler *scorehandler = gt_scorehandler_new(matchscore,
                                                     mismatchscore, 0,
                                                     gapscore);
  score = gt_squarealign_calculate_local_generic(spacemanager, align,
                                                 useq, ustart, ulen,
                                                 vseq, vstart, vlen,
                                                 scorehandler);
  gt_scorehandler_delete(scorehandler);
  return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
testq %rsi, %rsi
je 0x17a1f0
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0x17137c
movq %rax, %rbx
subq $0x8, %rsp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq 0x8(%rsp), %r9
pushq %rax
pushq 0x58(%rsp)
pushq 0x58(%rsp)
callq 0x179e17
addq $0x20, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x1713ff
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x55e61
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sspliced_alignment.c
// Function: gt_sspliced_alignment_new
GtSSplicedAlignment* gt_sspliced_alignment_new(const char *id, bool forward)
{
  GtSSplicedAlignment *sa;
  gt_assert(id);
  sa = gt_malloc(sizeof *sa);
  sa->id = gt_cstr_dup(id);
  sa->forward = forward;
  sa->exons = gt_array_new(sizeof (GtRange));
  return sa;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x17a246
movl %esi, %ebx
movq %rdi, %r14
leaq 0x21a52c(%rip), %rsi    # 0x39473a
movl $0x18, %edi
movl $0x20, %edx
callq 0x104226
movq %rax, %r15
movq %r14, %rdi
callq 0xe4290
movq %rax, (%r15)
movb %bl, 0x8(%r15)
movl $0x10, %edi
callq 0xd214c
movq %rax, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x55e9a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sspliced_alignment.c
// Function: gt_sspliced_alignment_delete
void gt_sspliced_alignment_delete(GtSSplicedAlignment *sa)
{
  if (!sa) return;
  gt_array_delete(sa->exons);
  gt_free(sa->id);
  gt_free(sa);
}

// Assembly:
testq %rdi, %rdi
je 0x17a28e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xd2938
movq (%rbx), %rdi
leaq 0x21a4d0(%rip), %r14    # 0x39473a
movq %r14, %rsi
movl $0x2b, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2c, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sspliced_alignment.c
// Function: gt_sspliced_alignment_genomic_range
GtRange gt_sspliced_alignment_genomic_range(const GtSSplicedAlignment *sa)
{
  GtRange range;
  gt_assert(sa);
  gt_assert(gt_array_size(sa->exons));
  range.start = ((GtRange*) gt_array_get_first(sa->exons))->start;
  range.end   = ((GtRange*) gt_array_get_last(sa->exons))->end;
  return range;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x17a340
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x17a345
movq 0x10(%rbx), %rdi
callq 0xd2224
movq (%rax), %r14
movq 0x10(%rbx), %rdi
callq 0xd222b
movq 0x8(%rax), %rdx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x55fe4
callq 0x55fad
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sspliced_alignment.c
// Function: gt_sspliced_alignment_compare_ptr
int gt_sspliced_alignment_compare_ptr(const GtSSplicedAlignment **sa_a,
                                   const GtSSplicedAlignment **sa_b)
{
  GtRange range_a, range_b;
  range_a = gt_sspliced_alignment_genomic_range(*sa_a);
  range_b = gt_sspliced_alignment_genomic_range(*sa_b);
  return range_compare_long_first(range_a, range_b);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq (%rdi), %rdi
callq 0x17a302
movq %rax, %r14
movq %rdx, %rbx
movq (%r15), %rdi
callq 0x17a302
cmpq %rbx, %r14
ja 0x17a3a8
cmpq %rdx, %rax
ja 0x17a3a8
movq %r14, %rsi
xorq %rax, %rsi
movq %rbx, %rdi
xorq %rdx, %rdi
xorl %ecx, %ecx
orq %rsi, %rdi
je 0x17a3a0
cmpq %rax, %r14
sete %al
setb %cl
cmpq %rdx, %rbx
seta %dl
andb %al, %dl
orb %cl, %dl
movzbl %dl, %ecx
negl %ecx
orl $0x1, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5601b
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stat_stream.c
// Function: gt_stat_stream_class
const GtNodeStreamClass* gt_stat_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtStatStream),
                                   stat_stream_free,
                                   stat_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x34426e(%rip)    # 0x4be8c0
jne 0x17a673
leaq 0x26(%rip), %rsi        # 0x17a681
leaq 0x49(%rip), %rdx        # 0x17a6ab
movl $0x28, %edi
callq 0x162d34
movq %rax, 0x34424d(%rip)    # 0x4be8c0
callq 0xe2545
movq 0x344241(%rip), %rax    # 0x4be8c0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stat_stream.c
// Function: stat_stream_next
static int stat_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err)
{
  GtStatStream *stat_stream;
  int had_err;
  gt_error_check(err);
  stat_stream = stat_stream_cast(ns);
  had_err = gt_node_stream_next(stat_stream->in_stream, gn, err);
  if (!had_err) {
    gt_assert(stat_stream->stat_visitor);
    if (*gn) {
      if (!gt_eof_node_try_cast(*gn)) /* do not count EOF nodes */
        stat_stream->number_of_DAGs++;
      had_err = gt_genome_node_accept(*gn, stat_stream->stat_visitor, err);
      gt_assert(!had_err); /* the status visitor is sane */
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x17a6cc
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x17a731
callq 0x17a644
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x162e68
movl %eax, %ebp
testl %eax, %eax
jne 0x17a724
cmpq $0x0, 0x18(%r15)
je 0x17a736
movq (%r14), %rdi
testq %rdi, %rdi
je 0x17a724
callq 0x2fda49
testq %rax, %rax
jne 0x17a711
incq 0x20(%r15)
movq (%r14), %rdi
movq 0x18(%r15), %rsi
movq %rbx, %rdx
callq 0x14472c
testl %eax, %eax
jne 0x17a73b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x560f7
callq 0x56165
callq 0x5612e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stat_stream.c
// Function: gt_stat_stream_new
GtNodeStream* gt_stat_stream_new(GtNodeStream *in_stream,
                                 bool gene_length_distri,
                                 bool gene_score_distri,
                                 bool exon_length_distri,
                                 bool exon_number_distri,
                                 bool intron_length_distri,
                                 bool cds_length_distri,
                                 bool used_sources)
{
  GtNodeStream *ns = gt_node_stream_create(gt_stat_stream_class(), false);
  GtStatStream *ss = stat_stream_cast(ns);
  ss->in_stream = gt_node_stream_ref(in_stream);
  ss->stat_visitor = gt_stat_visitor_new(gene_length_distri, gene_score_distri,
                                         exon_length_distri, exon_number_distri,
                                         intron_length_distri,
                                         cds_length_distri, used_sources);
  return ns;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0x14(%rsp)
movl %r8d, 0x10(%rsp)
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
callq 0x17a644
movq %rax, %rdi
xorl %esi, %esi
callq 0x162d6c
movq %rax, %r13
callq 0x17a644
movq %rax, %rdi
movq %r13, %rsi
callq 0x162ff7
movq %rax, %rbp
movq %rbx, %rdi
callq 0x162dd8
movq %rax, 0x10(%rbp)
movzbl 0x58(%rsp), %eax
movl %eax, (%rsp)
movzbl 0x50(%rsp), %r9d
movl %r12d, %edi
movl %r15d, %esi
movl %r14d, %edx
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %r8d
callq 0x17a978
movq %rax, 0x18(%rbp)
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stat_visitor.c
// Function: gt_stat_visitor_class
const GtNodeVisitorClass* gt_stat_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtStatVisitor),
                                    stat_visitor_free,
                                    NULL,
                                    stat_visitor_feature_node,
                                    stat_visitor_region_node,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x3440b6(%rip)    # 0x4be8c8
jne 0x17a847
movq $0x0, (%rsp)
leaq 0x32(%rip), %rsi        # 0x17a855
leaq 0x9d(%rip), %rcx        # 0x17a8c7
leaq 0xe6(%rip), %r8         # 0x17a917
movl $0xb0, %edi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x344081(%rip)    # 0x4be8c8
callq 0xe2545
movq 0x344075(%rip), %rax    # 0x4be8c8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stat_visitor.c
// Function: stat_visitor_free
static void stat_visitor_free(GtNodeVisitor *nv)
{
  GtStatVisitor *sv = stat_visitor_cast(nv);
  gt_cstr_table_delete(sv->used_sources);
  gt_disc_distri_delete(sv->cds_length_distribution);
  gt_disc_distri_delete(sv->intron_length_distribution);
  gt_disc_distri_delete(sv->exon_number_distribution);
  gt_disc_distri_delete(sv->exon_length_distribution);
  gt_disc_distri_delete(sv->gene_score_distribution);
  gt_disc_distri_delete(sv->gene_length_distribution);
  gt_string_distri_delete(sv->type_counts);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x17a804
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %rbx
movq 0xa0(%rax), %rdi
callq 0xe4c43
movq 0x98(%rbx), %rdi
callq 0xe5a93
movq 0x90(%rbx), %rdi
callq 0xe5a93
movq 0x88(%rbx), %rdi
callq 0xe5a93
movq 0x80(%rbx), %rdi
callq 0xe5a93
movq 0x78(%rbx), %rdi
callq 0xe5a93
movq 0x70(%rbx), %rdi
callq 0xe5a93
movq 0xa8(%rbx), %rdi
popq %rbx
jmp 0x11c57d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stat_visitor.c
// Function: stat_visitor_feature_node
static int stat_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                                     GtError *err)
{
  GtStatVisitor *sv;
  gt_error_check(err);
  sv = stat_visitor_cast(nv);
  return gt_feature_node_traverse_children(fn, sv, compute_statistics, false,
                                           err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x17a8e6
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x17a912
callq 0x17a804
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
leaq 0x40e(%rip), %rdx       # 0x17ad0b
movq %r14, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x142d9d
callq 0x5619c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stat_visitor.c
// Function: stat_visitor_region_node
static int stat_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                    GT_UNUSED GtError *err)
{
  GtStatVisitor *sv;
  GtRange range;
  gt_error_check(err);
  sv = stat_visitor_cast(nv);
  sv->number_of_sequence_regions++;
  range = gt_genome_node_get_range((GtGenomeNode*) rn);
  sv->total_length_of_sequence_regions += gt_range_length(&range);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x17a935
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x17a973
callq 0x17a804
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
incq 0x10(%rax)
movq %rbx, %rdi
callq 0x144679
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x112233
addq %rax, 0x68(%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x561d5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stat_visitor.c
// Function: gt_stat_visitor_new
GtNodeVisitor* gt_stat_visitor_new(bool gene_length_distri,
                                   bool gene_score_distri,
                                   bool exon_length_distri,
                                   bool exon_number_distri,
                                   bool intron_length_distri,
                                   bool cds_length_distri,
                                   bool used_sources)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_stat_visitor_class());
  GtStatVisitor *sv = stat_visitor_cast(nv);
  if (gene_length_distri)
    sv->gene_length_distribution = gt_disc_distri_new();
  if (gene_score_distri)
    sv->gene_score_distribution = gt_disc_distri_new();
  if (exon_length_distri)
    sv->exon_length_distribution = gt_disc_distri_new();
  if (exon_number_distri)
    sv->exon_number_distribution = gt_disc_distri_new();
  if (intron_length_distri)
    sv->intron_length_distribution = gt_disc_distri_new();
  if (cds_length_distri)
    sv->cds_length_distribution = gt_disc_distri_new();
  sv->type_counts = gt_string_distri_new();
  if (used_sources)
    sv->used_sources = gt_cstr_table_new();
  return nv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, (%rsp)
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %ebp
movl %edi, %r15d
callq 0x17a804
movq %rax, %rdi
callq 0x163080
movq %rax, %rbx
callq 0x17a804
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %r14
testl %r15d, %r15d
je 0x17a9c8
callq 0xe54e0
movq %rax, 0x70(%r14)
testb %bpl, %bpl
je 0x17a9d6
callq 0xe54e0
movq %rax, 0x78(%r14)
testb %r13b, %r13b
je 0x17a9e7
callq 0xe54e0
movq %rax, 0x80(%r14)
testb %r12b, %r12b
je 0x17a9f8
callq 0xe54e0
movq %rax, 0x88(%r14)
cmpb $0x0, (%rsp)
je 0x17aa0a
callq 0xe54e0
movq %rax, 0x90(%r14)
movb 0x40(%rsp), %bpl
cmpb $0x0, 0x4(%rsp)
je 0x17aa22
callq 0xe54e0
movq %rax, 0x98(%r14)
callq 0x11c288
movq %rax, 0xa8(%r14)
testb %bpl, %bpl
je 0x17aa3f
callq 0xe48d0
movq %rax, 0xa0(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/stat_visitor.c
// Function: add_exon_or_cds_number
static int add_exon_or_cds_number(GtFeatureNode *fn, void *data,
                                  GT_UNUSED GtError *err)
{
  GtStatVisitor *sv = (GtStatVisitor*) data;
  gt_error_check(err);
  gt_assert(sv && fn);
  if (gt_feature_node_has_type(fn, gt_ft_exon))
    sv->exon_number_for_distri++;
  else if (gt_feature_node_has_type(fn, gt_ft_CDS)) {
    GtRange range = gt_genome_node_get_range((GtGenomeNode*) fn);
    sv->cds_length_for_distri += gt_range_length(&range);
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x17b030
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x17b092
testq %r14, %r14
je 0x17b08d
testq %rbx, %rbx
je 0x17b08d
leaq 0x219756(%rip), %rsi    # 0x394797
movq %r14, %rdi
callq 0x142b18
testb %al, %al
je 0x17b053
incq 0x58(%rbx)
jmp 0x17b083
leaq 0x2073bf(%rip), %rsi    # 0x382419
movq %r14, %rdi
callq 0x142b18
testb %al, %al
je 0x17b083
movq %r14, %rdi
callq 0x144679
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x112233
addq %rax, 0x60(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x5635e
callq 0x56327
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/string_matching.c
// Function: gt_string_matching_bmh
void gt_string_matching_bmh(const char *s, GtUword n,
                            const char *p, GtUword m,
                            GtProcessMatch process_match, void *data)
{
  GtUword i, j, pos, d[UCHAR_MAX];
  gt_assert(s && p);
  if (m > n || !m || !n) /* no match possible */
    return;
  /* preprocessing */
  for (i = 0; i < UCHAR_MAX; i++)
    d[i] = m;
  for (j = 0; j < m-1; j++)
    d[(unsigned) p[j]] = m-(j+1);
  /* searching */
  pos = 0;
  while (pos <= n-m) {
    j = m;
    while (j > 0 && s[pos+j-1] == p[j-1])
      j--;
    if (j == 0 && process_match) {
      if (process_match(pos, data))
        return;
    }
    pos += d[(unsigned) s[pos+m-1]];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %r9, (%rsp)
testq %rdi, %rdi
je 0x17e1a2
movq %rdx, %r12
testq %rdx, %rdx
je 0x17e1a2
movq %rcx, %r15
movq %rsi, %r14
leaq -0x1(%rcx), %rax
cmpq %rsi, %rax
jae 0x17e190
movq %r8, %r13
movq %rdi, %rsi
movdqa 0x1da96d(%rip), %xmm0   # 0x358a20
xorl %ecx, %ecx
movdqa 0x1da973(%rip), %xmm1   # 0x358a30
movdqa 0x2176fb(%rip), %xmm2   # 0x3957c0
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x1da96e(%rip), %xmm4   # 0x358a40
movdqa %xmm0, %xmm5
pxor %xmm1, %xmm5
movdqa %xmm2, %xmm6
pcmpgtd %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pcmpeqd %xmm3, %xmm5
pand %xmm6, %xmm5
movd %xmm5, %edx
testb $0x1, %dl
je 0x17e0fd
movq %r15, 0x10(%rsp,%rcx,8)
pextrw $0x4, %xmm5, %edx
testb $0x1, %dl
je 0x17e10c
movq %r15, 0x18(%rsp,%rcx,8)
addq $0x2, %rcx
paddq %xmm4, %xmm0
cmpq $0x100, %rcx            # imm = 0x100
jne 0x17e0d2
testq %rax, %rax
je 0x17e138
movq %r12, %rcx
movsbq (%rcx), %rdx
movl %edx, %edx
movq %rax, 0x10(%rsp,%rdx,8)
incq %rcx
decq %rax
jne 0x17e125
subq %r15, %r14
leaq (%rsi,%r15), %rbp
decq %rbp
decq %rsi
movq %rsi, 0x8(%rsp)
xorl %ebx, %ebx
testq %r15, %r15
je 0x17e16b
movq 0x8(%rsp), %rax
addq %rbx, %rax
movq %r15, %rcx
movb (%rax,%rcx), %dl
cmpb -0x1(%r12,%rcx), %dl
jne 0x17e17e
decq %rcx
jne 0x17e15c
testq %r13, %r13
je 0x17e17e
movq %rbx, %rdi
movq (%rsp), %rsi
callq *%r13
testb %al, %al
jne 0x17e190
movsbq (%rbp,%rbx), %rax
movl %eax, %eax
addq 0x10(%rsp,%rax,8), %rbx
cmpq %r14, %rbx
jbe 0x17e14c
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x56fdf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/string_matching.c
// Function: gt_string_matching_shift_and
void gt_string_matching_shift_and(const char *s, GtUword n,
                                  const char *p, GtUword m,
                                  GtProcessMatch process_match, void *data)
{
  GtBittab *D, *B[UCHAR_MAX] = { NULL };
  GtUword i, j;
  gt_assert(s && p);
  if (m > n || !m || !n) /* no match possible */
    return;
  /* preprocessing */
  for (j = 0; j < m; j++) {
    if (!B[(unsigned) p[j]])
      B[(unsigned) p[j]] = gt_bittab_new(m);
    gt_bittab_set_bit(B[(unsigned) p[j]], j);
  }
  /* searching */
  D = gt_bittab_new(m);
  for (i = 0; i < n; i++) {
    gt_bittab_shift_left_equal(D);
    gt_bittab_set_bit(D, 0);
    if (B[(unsigned) s[i]])
      gt_bittab_and_equal(D, B[(unsigned) s[i]]);
    else
      gt_bittab_unset(D);
    if (gt_bittab_bit_is_set(D, m - 1) && process_match) {
      if (process_match(i - m + 1, data))
        break;
    }
  }
  /* free */
  for (i = 0; i < UCHAR_MAX; i++)
    gt_bittab_delete(B[i]);
  gt_bittab_delete(D);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r13
leaq 0x10(%rsp), %rdi
movl $0x7f8, %edx            # imm = 0x7F8
xorl %esi, %esi
callq 0x173a0
testq %r13, %r13
je 0x17e471
testq %rbx, %rbx
je 0x17e471
leaq -0x1(%r15), %rbp
cmpq (%rsp), %rbp
jae 0x17e45f
xorl %r12d, %r12d
movsbq (%rbx,%r12), %rax
movl %eax, %eax
movq 0x10(%rsp,%rax,8), %rdi
testq %rdi, %rdi
jne 0x17e3aa
movq %r15, %rdi
callq 0xd6a50
movq %rax, %rdi
movsbq (%rbx,%r12), %rax
movl %eax, %eax
movq %rdi, 0x10(%rsp,%rax,8)
movq %r12, %rsi
callq 0xd6abc
incq %r12
cmpq %r12, %r15
jne 0x17e382
movq %r15, %rdi
callq 0xd6a50
movq %rax, %rbx
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0xd6d41
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd6abc
movsbq (%r13,%r12), %rax
movl %eax, %eax
movq 0x10(%rsp,%rax,8), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
je 0x17e3f6
callq 0xd6cbf
jmp 0x17e3fb
callq 0xd6db2
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xd6e4a
testq %r14, %r14
je 0x17e424
testb %al, %al
je 0x17e424
movq %r12, %rdi
subq %r15, %rdi
incq %rdi
movq 0x8(%rsp), %rsi
callq *%r14
testb %al, %al
jne 0x17e42d
incq %r12
cmpq (%rsp), %r12
jb 0x17e3c8
xorl %r14d, %r14d
movq 0x10(%rsp,%r14,8), %rdi
callq 0xd7151
incq %r14
cmpq $0xff, %r14
jne 0x17e430
movq %rbx, %rdi
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd7151
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5704d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/string_matching.c
// Function: gt_string_matching_brute_force
void gt_string_matching_brute_force(const char *s, GtUword n,
                                    const char *p, GtUword m,
                                    GtProcessMatch process_match, void *data)
{
  GtUword i;
  gt_assert(s && p);
  if (m > n || !m || !n) /* no match possible */
    return;
  for (i = 0; i <= n - m; i++) {
    GtUword j = 0;
    while (j < m && s[i+j] == p[j])
      j++;
    if (j == m && process_match) {
      if (process_match(i, data))
        break;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
testq %rdi, %rdi
je 0x17e4fb
movq %rdx, %r12
testq %rdx, %rdx
je 0x17e4fb
movq %rcx, %r15
movq %rsi, %r13
leaq -0x1(%rcx), %rax
cmpq %rsi, %rax
jae 0x17e4ec
movq %r8, %r14
movq %rdi, %rbp
subq %r15, %r13
xorl %ebx, %ebx
leaq (%rbx,%rbp), %rcx
xorl %eax, %eax
movb (%rcx,%rax), %dl
cmpb (%r12,%rax), %dl
jne 0x17e4c6
incq %rax
cmpq %rax, %r15
jne 0x17e4b2
movq %r15, %rax
testq %r14, %r14
sete %cl
cmpq %r15, %rax
setne %al
orb %cl, %al
jne 0x17e4e4
movq %rbx, %rdi
movq (%rsp), %rsi
callq *%r14
testb %al, %al
jne 0x17e4ec
incq %rbx
cmpq %r13, %rbx
jbe 0x17e4ac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x57086
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/string_matching.c
// Function: store_match
static bool store_match(GtUword pos, void *data)
{
  GtArray *positions = data;
  gt_assert(positions);
  gt_array_add(positions, pos);
  return false;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
testq %rsi, %rsi
je 0x17eb89
movq %rsp, %rax
movl $0x8, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0xd2410
xorl %eax, %eax
popq %rcx
retq
callq 0x570f8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/string_matching.c
// Function: store_first_match
static bool store_first_match(GtUword pos, void *data)
{
  GtUword *match = data;
  gt_assert(match);
  *match = pos;
  return true;
}

// Assembly:
testq %rsi, %rsi
je 0x17eb99
movq %rdi, (%rsi)
movb $0x1, %al
retq
pushq %rax
callq 0x57131
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/targetbest_select_stream.c
// Function: gt_targetbest_select_stream_class
const GtNodeStreamClass* gt_targetbest_select_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtTargetbestSelectStream),
                                   targetbest_select_stream_free,
                                   targetbest_select_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x33e27e(%rip)    # 0x4be8d0
jne 0x180673
leaq 0x26(%rip), %rsi        # 0x180681
leaq 0x7a(%rip), %rdx        # 0x1806dc
movl $0x38, %edi
callq 0x162d34
movq %rax, 0x33e25d(%rip)    # 0x4be8d0
callq 0xe2545
movq 0x33e251(%rip), %rax    # 0x4be8d0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/targetbest_select_stream.c
// Function: targetbest_select_stream_free
static void targetbest_select_stream_free(GtNodeStream *ns)
{
  GtTargetbestSelectStream *tfs = targetbest_select_stream_cast(ns);
  for (; tfs->next != NULL; tfs->next = gt_dlistelem_next(tfs->next))
    gt_genome_node_delete(gt_dlistelem_get_data(tfs->next));
  gt_dlist_delete(tfs->trees);
  gt_hashmap_delete(tfs->target_to_elem);
  gt_node_stream_delete(tfs->in_stream);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x180644
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x1806c0
movq %rax, %rdi
callq 0xe5c10
movq %rax, %rdi
callq 0x1451a0
movq 0x20(%rbx), %rdi
callq 0xe5c20
movq %rax, 0x20(%rbx)
jmp 0x18069c
movq 0x18(%rbx), %rdi
callq 0xe5e8d
movq 0x28(%rbx), %rdi
callq 0x10109b
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x162dee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/targetbest_select_stream.c
// Function: gt_targetbest_select_stream_new
GtNodeStream* gt_targetbest_select_stream_new(GtNodeStream *in_stream)
{
  GtTargetbestSelectStream *tfs;
  GtNodeStream *ns;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_targetbest_select_stream_class(),
                             gt_node_stream_is_sorted(in_stream));
  tfs = targetbest_select_stream_cast(ns);
  tfs->in_stream = gt_node_stream_ref(in_stream);
  tfs->in_stream_processed = false;
  tfs->trees = gt_dlist_new(NULL);
  tfs->target_to_elem = gt_hashmap_new(GT_HASH_STRING, gt_free_func, NULL);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x180a2f
movq %rdi, %r14
callq 0x180644
movq %rax, %rbx
movq %r14, %rdi
callq 0x162fe4
movzbl %al, %esi
movq %rbx, %rdi
callq 0x162d6c
movq %rax, %rbx
callq 0x180644
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %r15
movq %r14, %rdi
callq 0x162dd8
movq %rax, 0x10(%r15)
movb $0x0, 0x30(%r15)
xorl %edi, %edi
callq 0xe5b28
movq %rax, 0x18(%r15)
leaq -0x7c36c(%rip), %rsi    # 0x1046aa
movl $0x1, %edi
xorl %edx, %edx
callq 0x1008fc
movq %rax, 0x28(%r15)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x57e34
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/tir_stream.c
// Function: gt_tir_stream_class
const GtNodeStreamClass* gt_tir_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtTIRStream),
                                   gt_tir_stream_free,
                                   gt_tir_stream_next);
  }
  return nsc;
}

// Assembly:
movq 0x33d891(%rip), %rax    # 0x4be8e8
testq %rax, %rax
je 0x18105d
retq
pushq %rax
leaq 0x1d(%rip), %rsi        # 0x181082
leaq 0xcb(%rip), %rdx        # 0x181137
movl $0x120, %edi            # imm = 0x120
callq 0x162d34
movq %rax, 0x33d86b(%rip)    # 0x4be8e8
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/tir_stream.c
// Function: gt_tir_stream_free
static void gt_tir_stream_free(GtNodeStream *ns)
{
  GtTIRStream *tir_stream = gt_node_stream_cast(gt_tir_stream_class(), ns);
  GT_FREEARRAY(&tir_stream->first_pairs, TIRPair);
  gt_str_delete(tir_stream->str_indexname);
  if (tir_stream->ssar != NULL)
    gt_freeSequentialsuffixarrayreader(&tir_stream->ssar);
  if (tir_stream->tir_pairs != NULL)
    gt_free(tir_stream->tir_pairs);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x33d858(%rip), %rdi    # 0x4be8e8
testq %rdi, %rdi
jne 0x1810b7
leaq -0x1a(%rip), %rsi       # 0x181082
leaq 0x94(%rip), %rdx        # 0x181137
movl $0x120, %edi            # imm = 0x120
callq 0x162d34
movq %rax, %rdi
movq %rax, 0x33d831(%rip)    # 0x4be8e8
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x78(%rax), %rdi
testq %rdi, %rdi
je 0x1810ef
leaq 0x78(%rbx), %r14
leaq 0x2157b4(%rip), %rsi    # 0x39688a
movl $0x3be, %edx            # imm = 0x3BE
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xb0(%rbx), %rdi
callq 0x11bdbf
cmpq $0x0, 0x18(%rbx)
je 0x18110e
movq %rbx, %rdi
addq $0x18, %rdi
callq 0x1a5698
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x18112f
leaq 0x21576c(%rip), %rsi    # 0x39688a
movl $0x3c3, %edx            # imm = 0x3C3
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/tir_stream.c
// Function: gt_tir_store_seeds
static int gt_tir_store_seeds(void *info, const GtGenericEncseq *genericencseq,
                              GtUword len, GtUword pos1,
                              GtUword pos2, GT_UNUSED GtError *err)
{
  GtUword seqnum1,
                seqnum2;
  Seed *nextfreeseedpointer;
  GtUword distance;
  SeedInfo *seeds = (SeedInfo *) info;
  const GtEncseq *encseq;
  gt_error_check(err);

  gt_assert(genericencseq->hasencseq);
  encseq = genericencseq->seqptr.encseq;
  /* ensure order of seeds */
  gt_assert(pos1 < pos2);

  /* match mirrored vs. unmirrored */
  if (pos1 > seeds->midpos || pos2 < seeds->midpos)
    return 0;

  /* check distance constraints */
  distance = (GT_REVERSEPOS(seeds->totallength, pos2) - len + 1) - pos1;
  if (distance < seeds->min_tir_distance || distance > seeds->max_tir_distance)
    return 0;

  /* check whether matches are on the `same' contig */
  seqnum1 = gt_encseq_seqnum(encseq, pos1);
  seqnum2 = gt_encseq_seqnum(encseq, pos2);
  if (seqnum2 != seeds->num_of_contigs - seqnum1 - 1)
    return 0;

  /* check length constraints */
  if (len > seeds->max_tir_length)
    return 0;

  GT_GETNEXTFREEINARRAY(nextfreeseedpointer, &seeds->seed, Seed, 256);
  nextfreeseedpointer->pos1 = pos1;
  nextfreeseedpointer->pos2 = pos2;
  nextfreeseedpointer->offset = distance;
  nextfreeseedpointer->len = len;
  nextfreeseedpointer->contignumber = seqnum1;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
testq %r9, %r9
je 0x1826bd
movq %r9, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1827d0
cmpb $0x0, (%r13)
je 0x1827c6
cmpq %r14, %r15
jae 0x1827cb
movq 0x40(%r12), %rax
cmpq %r15, %rax
setb %cl
cmpq %r14, %rax
seta %al
orb %cl, %al
jne 0x1827b5
movq 0x48(%r12), %rbp
leaq (%r15,%rbx), %rax
addq %r14, %rax
subq %rax, %rbp
cmpq 0x30(%r12), %rbp
jb 0x1827b5
cmpq 0x28(%r12), %rbp
ja 0x1827b5
movq 0x8(%r13), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0xeb655
movq %r13, %rdi
movq %rax, %r13
movq %r14, %rsi
callq 0xeb655
movq %r13, %rcx
notq %rcx
addq 0x38(%r12), %rcx
cmpq %rcx, %rax
jne 0x1827b5
cmpq %rbx, 0x18(%r12)
jb 0x1827b5
movq 0x8(%r12), %rax
cmpq %rax, 0x10(%r12)
jae 0x182755
movq (%r12), %rax
jmp 0x182786
leaq 0x100(%rax), %rcx
movq %rcx, 0x8(%r12)
movq (%r12), %rdi
leaq 0x800(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
leaq 0x214112(%rip), %rdx    # 0x39688a
movl $0xab, %ecx
callq 0x104461
movq %rax, (%r12)
testq %rax, %rax
je 0x1827d5
movq 0x10(%r12), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%r12)
leaq (%rcx,%rcx,4), %rcx
movq %r15, (%rax,%rcx,8)
movq %r14, 0x8(%rax,%rcx,8)
movq %rbp, 0x10(%rax,%rcx,8)
movq %rbx, 0x18(%rax,%rcx,8)
movq %r13, 0x20(%rax,%rcx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x584d6
callq 0x5850f
callq 0x5849d
callq 0x58548
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/tir_stream.c
// Function: gt_tir_store_TSDs
static void gt_tir_store_TSDs(void *info, const GtQuerymatch *querymatch)
{
  Seed *nextfree;
  TSDinfo *TSDs = (TSDinfo *) info;

  /* store the TSD  */
  GT_GETNEXTFREEINARRAY(nextfree, &TSDs->TSDs, Seed, 100);
  nextfree->pos1 = TSDs->left_start_pos + gt_querymatch_dbstart(querymatch);
  nextfree->offset = TSDs->right_start_pos
                       + gt_querymatch_querystart(querymatch)
                       - (nextfree->pos1);
  nextfree->len = gt_querymatch_querylen(querymatch);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
cmpq %rax, 0x20(%rdi)
jae 0x18282e
movq 0x10(%r14), %r15
jmp 0x18285e
leaq 0x64(%rax), %rcx
movq %rcx, 0x18(%r14)
movq 0x10(%r14), %rdi
leaq 0x320(,%rax,8), %rax
leaq (%rax,%rax,4), %rsi
leaq 0x21403d(%rip), %rdx    # 0x39688a
movl $0xba, %ecx
callq 0x104461
movq %rax, %r15
movq %rax, 0x10(%r14)
testq %r15, %r15
je 0x1828b4
movq (%r14), %r12
movq 0x20(%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r14)
leaq (%rax,%rax,4), %r13
movq %rbx, %rdi
callq 0x1bac26
addq %r12, %rax
movq %rax, (%r15,%r13,8)
movq 0x8(%r14), %r14
movq %rbx, %rdi
callq 0x1bac39
addq %r14, %rax
subq (%r15,%r13,8), %rax
movq %rax, 0x10(%r15,%r13,8)
movq %rbx, %rdi
callq 0x1bac21
movq %rax, 0x18(%r15,%r13,8)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x58581
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/typecheck_info.c
// Function: gt_typecheck_info_delete
void gt_typecheck_info_delete(GtTypecheckInfo *tci)
{
  if (!tci) return;
  gt_option_delete(tci->typecheck_option);
  gt_str_delete(tci->typecheck);
  gt_free(tci);
}

// Assembly:
testq %rdi, %rdi
je 0x183307
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x10a16a
movq (%rbx), %rdi
callq 0x11bdbf
leaq 0x214243(%rip), %rsi    # 0x39753c
movq %rbx, %rdi
movl $0x2c, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/typecheck_info.c
// Function: gt_typecheck_info_register_options_with_default
void gt_typecheck_info_register_options_with_default(GtTypecheckInfo *tci,
                                                     GtOptionParser *op,
                                                     const char *default_v)
{
  GtOption *typecheck_option, *built_in_option;
  gt_assert(tci && op);
  gt_assert(!tci->typecheck_option); /* can only called once */

  /* -typecheck */
  typecheck_option =
    gt_option_new_string("typecheck", "use an ontology given in an OBO file "
                         "to validate parent-child relationships.\n"
                         "If no argument is given, "
                         "the sofa.obo file from the gtdata/obo_files "
                         "directory is used.\nIf an argument is given, it is "
                         "used as an OBO filename.\nIn the case that such a "
                         "file does not exist '.obo' is added to the argument "
                         "and loading the resulting filename from the "
                         "gtdata/obo_files directory is attempted.",
                         tci->typecheck, default_v);
  gt_option_argument_is_optional(typecheck_option);
  gt_option_parser_add_option(op, typecheck_option);
  tci->typecheck_option = gt_option_ref(typecheck_option);

  /* -typecheck-built-in */
  built_in_option = gt_option_new_bool("typecheck-built-in",
                                       "use built-in type checker",
                                       &tci->typecheck_built_in, false);
  gt_option_is_development_option(built_in_option);
  gt_option_parser_add_option(op, built_in_option);
  gt_option_exclude(typecheck_option, built_in_option);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1833ad
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1833ad
movq %rdi, %r14
cmpq $0x0, 0x8(%rdi)
jne 0x1833b2
movq %rdx, %rcx
movq (%r14), %rdx
leaq 0x21426e(%rip), %rdi    # 0x3975ab
leaq 0x214271(%rip), %rsi    # 0x3975b5
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10ac2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x107bec
movq %rax, 0x8(%r14)
addq $0x10, %r14
leaq 0x2143bd(%rip), %rdi    # 0x397733
leaq 0x2143c9(%rip), %rsi    # 0x397746
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r14
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x107cc0
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x10ab96
callq 0x59041
callq 0x59078
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/typecheck_info.c
// Function: gt_typecheck_info_option_used
bool gt_typecheck_info_option_used(const GtTypecheckInfo *tci)
{
  gt_assert(tci && tci->typecheck_option);
  if (gt_option_is_set(tci->typecheck_option) || tci->typecheck_built_in)
    return true;
  return false;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1833e2
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1833e2
callq 0x10ac3f
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1833e0
movb 0x10(%rbx), %al
popq %rbx
retq
callq 0x590af
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/typecheck_info.c
// Function: gt_typecheck_info_create_type_checker
GtTypeChecker* gt_typecheck_info_create_type_checker(const GtTypecheckInfo *tci,
                                                     GtError *err)
{
  GtTypeChecker *type_checker = NULL;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(tci);
  if (tci->typecheck_built_in)
    type_checker = gt_type_checker_builtin_new();
  else {
    GtStr *obo_file;
    gt_assert(gt_option_is_set(tci->typecheck_option));
    if (!gt_str_length(tci->typecheck)) {
      /* a. */
      if (!(obo_file = get_obo_path(err)))
        had_err = -1;
      if (!had_err)
        gt_str_append_cstr(obo_file, "sofa.obo");
    }
    else if (gt_file_exists(gt_str_get(tci->typecheck))) {
      /* b. */
      obo_file = gt_str_new_cstr(gt_str_get(tci->typecheck));
    }
    else {
      /* c. */
      if (!(obo_file = get_obo_path(err)))
        had_err = -1;
      if (!had_err) {
        gt_str_append_str(obo_file, tci->typecheck);
        gt_str_append_cstr(obo_file, ".obo");
      }
    }

    if (!had_err)
      type_checker = gt_type_checker_obo_new(gt_str_get(obo_file), err);

    gt_str_delete(obo_file);
  }
  return type_checker;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x183407
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1834e0
testq %r14, %r14
je 0x1834db
cmpb $0x1, 0x10(%r14)
jne 0x183423
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x183280
movq 0x8(%r14), %rdi
callq 0x10ac3f
testb %al, %al
je 0x1834e5
movq (%r14), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0x18346a
movq (%r14), %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff28c
testb %al, %al
je 0x183483
movq (%r14), %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0x11acc9
movq %rax, %r15
jmp 0x1834ad
movq %rbx, %rdi
callq 0x1834ea
testq %rax, %rax
je 0x1834c5
movq %rax, %r15
leaq 0x21436c(%rip), %rsi    # 0x3977ed
jmp 0x1834a5
movq %rbx, %rdi
callq 0x1834ea
testq %rax, %rax
je 0x1834c5
movq %rax, %r15
movq (%r14), %rsi
movq %rax, %rdi
callq 0x11adc1
leaq 0x21434c(%rip), %rsi    # 0x3977f1
movq %r15, %rdi
callq 0x11acf3
movq %r15, %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %rbx, %rsi
callq 0x302b07
movq %rax, %rbx
jmp 0x1834ca
xorl %r15d, %r15d
xorl %ebx, %ebx
movq %r15, %rdi
callq 0x11bdbf
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x59154
callq 0x590e6
callq 0x5911d