LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_expect_index
static int spec_expect_index(lua_State *L)
{
  const char *matcher_name;
  GtSpecVisitor *sv;

  /* get parameters from stack */
  matcher_name = lua_tostring(L, 2);
  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);

  /* we can't do closures as nicely as in Lua -- keep this around for later */
  sv->matcher_name = matcher_name;

  /* return dispatcher function */
  lua_pushcfunction(L, spec_expect_matchdispatch);

  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %esi
xorl %edx, %edx
callq 0x22db9e
movq %rax, %r14
leaq 0x344687(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
movq %r14, 0x58(%rax)
leaq 0x1e4(%rip), %rsi       # 0x180d82
movq %rbx, %rdi
xorl %edx, %edx
callq 0x22e48c
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_class
const GtNodeStreamClass* gt_splice_site_info_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSpliceSiteInfoStream),
                                   gt_splice_site_info_stream_free,
                                   gt_splice_site_info_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x34890a(%rip)    # 0x4c98b0
jne 0x180fc7
leaq 0x26(%rip), %rsi        # 0x180fd5
leaq 0x49(%rip), %rdx        # 0x180fff
movl $0x20, %edi
callq 0x16abb4
movq %rax, 0x3488e9(%rip)    # 0x4c98b0
callq 0xe6a19
movq 0x3488dd(%rip), %rax    # 0x4c98b0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_next
static int gt_splice_site_info_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                           GtError *err)
{
  GtSpliceSiteInfoStream *ssis;
  int had_err;
  gt_error_check(err);
  ssis = gt_splice_site_info_stream_cast(ns);
  had_err = gt_node_stream_next(ssis->in_stream, gn, err);
  if (!had_err) {
    gt_assert(ssis->splice_site_info_visitor);
    if (*gn) {
      had_err = gt_genome_node_accept(*gn, ssis->splice_site_info_visitor, err);
      if (had_err) {
        /* we own the node -> delete it */
        gt_genome_node_delete(*gn);
        *gn = NULL;
      }
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x181020
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x18108b
callq 0x180f98
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16ace8
movl %eax, %ebp
testl %eax, %eax
je 0x181055
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r15), %rsi
testq %rsi, %rsi
je 0x181090
movq (%rbx), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x181048
movq %r14, %rdx
callq 0x14b992
testl %eax, %eax
je 0x181048
movl %eax, %r14d
movq (%rbx), %rdi
callq 0x14c43a
movq $0x0, (%rbx)
movl %r14d, %ebp
jmp 0x181048
callq 0x56894
callq 0x568cb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_new
GtNodeStream* gt_splice_site_info_stream_new(GtNodeStream *in_stream,
                                             GtRegionMapping *rm)
{
  GtNodeStream *ns = gt_node_stream_create(gt_splice_site_info_stream_class(),
                                           false);
  GtSpliceSiteInfoStream *ssis = gt_splice_site_info_stream_cast(ns);
  ssis->in_stream = gt_node_stream_ref(in_stream);
  ssis->splice_site_info_visitor = gt_splice_site_info_visitor_new(rm);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x180f98
movq %rax, %rdi
xorl %esi, %esi
callq 0x16abec
movq %rax, %r15
callq 0x180f98
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
movq %rax, %r12
movq %r14, %rdi
callq 0x16ac58
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x1814ac
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_O1/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_show
bool gt_splice_site_info_stream_show(GtNodeStream *ns, GtFile *outfp)
{
  GtSpliceSiteInfoStream *ssis;
  gt_assert(ns);
  ssis = gt_splice_site_info_stream_cast(ns);
  return gt_splice_site_info_visitor_show(ssis->splice_site_info_visitor,
                                          outfp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x181123
movq %rsi, %rbx
movq %rdi, %r14
callq 0x180f98
movq %rax, %rdi
movq %r14, %rsi
callq 0x16ae64
movq 0x18(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x181509
callq 0x56902
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_intron_processed
bool gt_splice_site_info_stream_intron_processed(GtNodeStream *ns)
{
  GtSpliceSiteInfoStream *ssis;
  gt_assert(ns);
  ssis = gt_splice_site_info_stream_cast(ns);
  return gt_splice_site_info_visitor_intron_processed(ssis
                                                    ->splice_site_info_visitor);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x18114b
movq %rdi, %rbx
callq 0x180f98
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq 0x18(%rax), %rdi
popq %rbx
jmp 0x18168a
callq 0x56939
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_show_canonical
bool gt_splice_site_info_stream_show_canonical(GtNodeStream *ns, bool show_gc)
{
  GtSpliceSiteInfoStream *ssis;
  gt_assert(ns);
  ssis = gt_splice_site_info_stream_cast(ns);
  return gt_splice_site_info_visitor_show_canonical(ssis
                                                    ->splice_site_info_visitor,
                                                    show_gc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x181181
movl %esi, %ebx
movq %rdi, %r14
callq 0x180f98
movq %rax, %rdi
movq %r14, %rsi
callq 0x16ae64
movq 0x18(%rax), %rdi
movzbl %bl, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1816ad
callq 0x56970
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_class
const GtNodeVisitorClass* gt_splice_site_info_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
   nvc = gt_node_visitor_class_new(sizeof (GtSpliceSiteInfoVisitor),
                                   splice_site_info_visitor_free,
                                   NULL,
                                   splice_site_info_visitor_feature_node,
                                   NULL,
                                   NULL,
                                   NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x348722(%rip)    # 0x4c98b8
jne 0x1811c7
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x1811d5
leaq 0x6d(%rip), %rcx        # 0x18121b
movl $0x38, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x3486f1(%rip)    # 0x4c98b8
callq 0xe6a19
movq 0x3486e5(%rip), %rax    # 0x4c98b8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: splice_site_info_visitor_free
static void splice_site_info_visitor_free(GtNodeVisitor *nv)
{
  GtSpliceSiteInfoVisitor *splice_site_info_visitor;
  gt_assert(nv);
  splice_site_info_visitor = splice_site_info_visitor_cast(nv);
  gt_region_mapping_delete(splice_site_info_visitor->region_mapping);
  gt_string_distri_delete(splice_site_info_visitor->splicesites);
  gt_string_distri_delete(splice_site_info_visitor->donorsites);
  gt_string_distri_delete(splice_site_info_visitor->acceptorsites);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x181216
movq %rdi, %rbx
callq 0x181188
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x1758da
movq 0x18(%rbx), %rdi
callq 0x1222cb
movq 0x20(%rbx), %rdi
callq 0x1222cb
movq 0x28(%rbx), %rdi
popq %rbx
jmp 0x1222cb
callq 0x569a7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_new
GtNodeVisitor* gt_splice_site_info_visitor_new(GtRegionMapping *rm)
{
  GtNodeVisitor *nv;
  GtSpliceSiteInfoVisitor *ssiv;
  gt_assert(rm);
  nv = gt_node_visitor_create(gt_splice_site_info_visitor_class());
  ssiv = splice_site_info_visitor_cast(nv);
  ssiv->region_mapping = rm;
  ssiv->splicesites = gt_string_distri_new();
  ssiv->acceptorsites = gt_string_distri_new();
  ssiv->donorsites = gt_string_distri_new();
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x181504
movq %rdi, %rbx
callq 0x181188
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r14
callq 0x181188
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r15
movq %rbx, 0x10(%rax)
callq 0x121fd0
movq %rax, 0x18(%r15)
callq 0x121fd0
movq %rax, 0x28(%r15)
callq 0x121fd0
movq %rax, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x56af1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_show
bool gt_splice_site_info_visitor_show(GtNodeVisitor *nv, GtFile *outfp)
{
  GtSpliceSiteInfoVisitor *ssiv;
  gt_assert(nv);
  ssiv = splice_site_info_visitor_cast(nv);

  if (ssiv->show) {
    /* show splice sites */
    gt_file_xprintf(outfp, "splice site distribution (for introns >= 4bp)\n");
    gt_string_distri_foreach(ssiv->splicesites, showsplicesite, outfp);
    gt_xputchar('\n');

    /* show donor sites */
    gt_file_xprintf(outfp, "donor site distribution (for introns >= 4bp)\n");
    gt_string_distri_foreach(ssiv->donorsites, showsinglesite, outfp);
    gt_xputchar('\n');

    /* show acceptor sites */
    gt_file_xprintf(outfp, "acceptor site distribution (for introns >= 4bp)\n");
    gt_string_distri_foreach(ssiv->acceptorsites, showsinglesite, outfp);
  }
  return ssiv->intron_processed;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1815bf
movq %rsi, %rbx
movq %rdi, %r14
callq 0x181188
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
cmpb $0x1, 0x30(%rax)
jne 0x1815b5
leaq 0x21c075(%rip), %rsi    # 0x39d5b2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x103d21
movq 0x18(%r14), %rdi
leaq 0x72(%rip), %rsi        # 0x1815c4
movq %rbx, %rdx
callq 0x1221da
movl $0xa, %edi
callq 0x1256e8
leaq 0x21c076(%rip), %rsi    # 0x39d5e1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x103d21
movq 0x20(%r14), %rdi
leaq 0xbe(%rip), %r15        # 0x18163e
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1221da
movl $0xa, %edi
callq 0x1256e8
leaq 0x21c073(%rip), %rsi    # 0x39d60f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x103d21
movq 0x28(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1221da
movb 0x31(%r14), %al
popq %rbx
popq %r14
popq %r15
retq
callq 0x56b2a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: showsplicesite
static void showsplicesite(const char *string, GtUword occurrences,
                           double probability, GT_UNUSED void *unused)
{
  gt_assert(string && strlen(string) == 4);
  gt_xputchar(string[0]);
  gt_xputchar(string[1]);
  gt_xputchar('-');
  gt_xputchar(string[2]);
  gt_xputchar(string[3]);
  printf(": %6.2f%% (n="GT_WU")\n", probability * 100.0, occurrences);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
testq %rdi, %rdi
je 0x181639
movq %rsi, %rbx
movq %rdi, %r14
callq 0x172f0
cmpq $0x4, %rax
jne 0x181639
movsbl (%r14), %edi
callq 0x1256e8
movsbl 0x1(%r14), %edi
callq 0x1256e8
movl $0x2d, %edi
callq 0x1256e8
movsbl 0x2(%r14), %edi
callq 0x1256e8
movsbl 0x3(%r14), %edi
callq 0x1256e8
movsd (%rsp), %xmm0
mulsd 0x1d11cf(%rip), %xmm0   # 0x3527f0
leaq 0x21c097(%rip), %rdi    # 0x39d6bf
movq %rbx, %rsi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17070
callq 0x56b63
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_intron_processed
bool gt_splice_site_info_visitor_intron_processed(GtNodeVisitor *nv)
{
  GtSpliceSiteInfoVisitor *ssiv;
  gt_assert(nv);
  ssiv = splice_site_info_visitor_cast(nv);
  return ssiv->intron_processed;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1816a8
movq %rdi, %rbx
callq 0x181188
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movb 0x31(%rax), %al
popq %rbx
retq
callq 0x56bd5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_show_canonical
bool gt_splice_site_info_visitor_show_canonical(GtNodeVisitor *nv, bool show_gc)
{
  GtSpliceSiteInfoVisitor *ssiv;
  bool canonical_shown = false;
  gt_assert(nv);
  ssiv = splice_site_info_visitor_cast(nv);

  if (ssiv->show) {
    GtUword occ;
    if ((occ = gt_string_distri_get(ssiv->splicesites, "gtag"))) {
      printf("gt-ag: %6.2f%% (n="GT_WU")\n",
             gt_string_distri_get_prob(ssiv->splicesites, "gtag") * 100.0, occ);
      canonical_shown = true;
    }
    if (show_gc && (occ = gt_string_distri_get(ssiv->splicesites, "gcag"))) {
      printf("gc-ag: %6.2f%% (n="GT_WU")\n",
             gt_string_distri_get_prob(ssiv->splicesites, "gcag") * 100.0, occ);
      canonical_shown = true;
    }
  }

  return canonical_shown;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x181780
movl %esi, %ebp
movq %rdi, %rbx
callq 0x181188
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
cmpb $0x1, 0x30(%rax)
jne 0x181721
movq %rax, %rbx
movq 0x18(%rax), %rdi
leaq 0x21bfb2(%rip), %rsi    # 0x39d698
callq 0x12211c
testq %rax, %rax
je 0x181726
movq %rax, %r15
movq 0x18(%rbx), %rdi
leaq 0x21bf9a(%rip), %rsi    # 0x39d698
callq 0x12214c
mulsd 0x1d10e5(%rip), %xmm0   # 0x3527f0
leaq 0x21bf8b(%rip), %rdi    # 0x39d69d
movb $0x1, %r14b
movq %r15, %rsi
movb $0x1, %al
callq 0x17070
jmp 0x181729
xorl %r14d, %r14d
jmp 0x181772
xorl %r14d, %r14d
testb %bpl, %bpl
je 0x181772
movq 0x18(%rbx), %rdi
leaq 0x21bf7c(%rip), %rsi    # 0x39d6b5
callq 0x12211c
testq %rax, %rax
je 0x181772
movq %rax, %r15
movq 0x18(%rbx), %rdi
leaq 0x21bf64(%rip), %rsi    # 0x39d6b5
callq 0x12214c
mulsd 0x1d1092(%rip), %xmm0   # 0x3527f0
leaq 0x21bf55(%rip), %rdi    # 0x39d6ba
movb $0x1, %r14b
movq %r15, %rsi
movb $0x1, %al
callq 0x17070
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x56c0e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/squarealign.c
// Function: gt_squarealign_calculate_generic
GtUword gt_squarealign_calculate_generic (GtLinspaceManagement *spacemanager,
                                          GtAlignment *align,
                                          const GtUchar *useq,
                                          GtUword ustart,
                                          GtUword ulen,
                                          const GtUchar *vseq,
                                          GtUword vstart,
                                          GtUword vlen,
                                          const GtScoreHandler *scorehandler)
{
  GtUword **E, distance;
  gt_assert(align && scorehandler);

  if (spacemanager == NULL)
  {
    /*use it in normally case*/
    gt_array2dim_malloc(E, (ulen+1), (vlen+1));
  }
  else
  {
    /*use it in lineraspace context*/
    E = gt_linspace_management_change_to_square(spacemanager,ulen,vlen);
  }
  fillDPtab_in_square_space(E, useq, ustart, ulen,
                            vseq, vstart, vlen, scorehandler);

  distance = E[ulen][vlen];
  /* reconstruct alignment from 2dimarray E */
  gt_reconstructalignment_from_EDtab(align, E, useq, ustart, ulen, vseq, vstart,
                                     vlen, scorehandler);
  if (spacemanager == NULL)
  {
    gt_array2dim_delete(E);
  }
  return distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x181dec
cmpq $0x0, 0x70(%rsp)
je 0x181dec
movq %r9, %r12
movq %r8, %r15
movq %rsi, 0x20(%rsp)
movq %rdx, %rbp
movq %rcx, %r13
movq 0x68(%rsp), %rbx
testq %rdi, %rdi
movq %rdi, 0x18(%rsp)
je 0x181cd2
movq %r15, %rsi
movq %rbx, %rdx
callq 0x163bd7
movq %rax, %r14
jmp 0x181d55
movq %r12, 0x8(%rsp)
leaq 0x1(%r15), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(,%r15,8), %r12
leaq 0x21bdd5(%rip), %rsi    # 0x39dac4
movq %r12, %rdi
movl $0x54, %edx
callq 0x1092b2
movq %rax, %r14
leaq 0x1(%rbx), %rdi
imulq %r12, %rdi
leaq 0x21bdb6(%rip), %rsi    # 0x39dac4
movl $0x54, %edx
callq 0x1092b2
movq %rax, (%r14)
cmpq $0x2, 0x10(%rsp)
jb 0x181d50
movq %rbx, %rsi
leaq 0x8(,%rbx,8), %rax
movq (%r14), %rcx
addq %rax, %rcx
xorl %edx, %edx
movq 0x8(%rsp), %r12
movq %rcx, 0x8(%r14,%rdx,8)
addq %rax, %rcx
incq %rdx
cmpq %rdx, %r15
jne 0x181d3b
movq %rsi, %rbx
jmp 0x181d55
movq 0x8(%rsp), %r12
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
movq 0x60(%rsp), %r9
movq 0x70(%rsp), %rax
pushq %rax
pushq %rbx
callq 0x181df1
addq $0x10, %rsp
movq (%r14,%r15,8), %rax
movq %r12, %r9
movq (%rax,%rbx,8), %r12
subq $0x8, %rsp
movq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
pushq 0x78(%rsp)
pushq %rbx
pushq 0x78(%rsp)
callq 0x174fb2
addq $0x20, %rsp
cmpq $0x0, 0x18(%rsp)
jne 0x181dda
movq (%r14), %rdi
leaq 0x21bd07(%rip), %rbx    # 0x39dac4
movq %rbx, %rsi
movl $0x64, %edx
callq 0x109670
movq %r14, %rdi
movq %rbx, %rsi
movl $0x64, %edx
callq 0x109670
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x56edd
// File: /workspace/github_c_makefile_star2_O1/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 0x1797fb
movq %rax, %r13
movq (%r15), %rax
movq $0x0, (%rax)
movq %rbx, 0x8(%rsp)
testq %rbx, %rbx
je 0x181e69
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 0x181e4f
cmpq $0x0, 0x50(%rsp)
je 0x181f17
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 0x181f09
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 0x17982a
addq %rbx, %rax
movq (%r15,%r14,8), %rcx
cmpq (%rcx,%r12,8), %rax
ja 0x181ee9
movq %rax, (%rcx,%r12,8)
movq -0x8(%r15,%r14,8), %rax
movq (%rax,%r12,8), %rax
addq %r13, %rax
cmpq (%rcx,%r12,8), %rax
jae 0x181eff
movq %rax, (%rcx,%r12,8)
incq %r14
cmpq 0x8(%rsp), %r14
jbe 0x181ea3
incq %r12
cmpq 0x50(%rsp), %r12
jbe 0x181e86
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/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 0x18202a
movq %r9, %rbx
movq %rdx, %r14
leaq 0x1(%rdx), %r15
leaq 0x8(,%rdx,8), %r13
leaq 0x21bb57(%rip), %rbp    # 0x39dac4
movq %r13, %rdi
movq %rbp, %rsi
movl $0x75, %edx
callq 0x1092b2
movq %rax, %r12
leaq 0x1(%rbx), %rdi
imulq %r13, %rdi
movq %rbp, %rsi
movl $0x75, %edx
callq 0x1092b2
movq %rax, (%r12)
cmpq $0x2, %r15
jb 0x181fc0
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 0x181fb0
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 0x181df1
addq $0x10, %rsp
movq (%r12,%r14,8), %rax
movq (%rax,%rbx,8), %rbx
movq (%r12), %rdi
leaq 0x21bac9(%rip), %r14    # 0x39dac4
movq %r14, %rsi
movl $0x79, %edx
callq 0x109670
movq %r12, %rdi
movq %r14, %rsi
movl $0x79, %edx
callq 0x109670
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x56f14
// File: /workspace/github_c_makefile_star2_O1/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 0x1820b2
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 0x179740
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 0x181c7c
addq $0x20, %rsp
movq %rax, %r14
movq %rbx, %rdi
callq 0x1797c3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x56f4b
// File: /workspace/github_c_makefile_star2_O1/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 0x126b6e
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 0x18202f
addq $0x30, %rsp
movq 0x341dca(%rip), %rax    # 0x4c3ee8
movq (%rax), %rdx
movq %r15, %rdi
movl $0x1, %esi
movl $0x50, %ecx
callq 0x1279ab
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x127c25
// File: /workspace/github_c_makefile_star2_O1/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 0x182776
movl %esi, %ebx
movq %rdi, %r14
leaq 0x21b4a3(%rip), %rsi    # 0x39dbe1
movl $0x18, %edi
movl $0x20, %edx
callq 0x1092b2
movq %rax, %r15
movq %r14, %rdi
callq 0xe8760
movq %rax, (%r15)
movb %bl, 0x8(%r15)
movl $0x10, %edi
callq 0xd46fc
movq %rax, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x570a1
// File: /workspace/github_c_makefile_star2_O1/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 0x1827be
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xd4ef4
movq (%rbx), %rdi
leaq 0x21b447(%rip), %r14    # 0x39dbe1
movq %r14, %rsi
movl $0x2b, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2c, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x182870
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x182875
movq 0x10(%rbx), %rdi
callq 0xd47d7
movq (%rax), %r14
movq 0x10(%rbx), %rdi
callq 0xd47de
movq 0x8(%rax), %rdx
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x571eb
callq 0x571b4
// File: /workspace/github_c_makefile_star2_O1/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 0x182832
movq %rax, %r14
movq %rdx, %rbx
movq (%r15), %rdi
callq 0x182832
cmpq %rbx, %r14
ja 0x1828d8
cmpq %rdx, %rax
ja 0x1828d8
movq %r14, %rsi
xorq %rax, %rsi
movq %rbx, %rdi
xorq %rdx, %rdi
xorl %ecx, %ecx
orq %rsi, %rdi
je 0x1828d0
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 0x57222
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x346d02(%rip)    # 0x4c98c0
jne 0x182bdf
leaq 0x26(%rip), %rsi        # 0x182bed
leaq 0x49(%rip), %rdx        # 0x182c17
movl $0x28, %edi
callq 0x16abb4
movq %rax, 0x346ce1(%rip)    # 0x4c98c0
callq 0xe6a19
movq 0x346cd5(%rip), %rax    # 0x4c98c0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x182c38
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x182c9f
callq 0x182bb0
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x16ace8
movl %eax, %ebp
testl %eax, %eax
jne 0x182c92
cmpq $0x0, 0x18(%r15)
je 0x182ca4
movq (%r14), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x182c92
callq 0x30774f
testq %rax, %rax
jne 0x182c7f
incq 0x20(%r15)
movq (%r14), %rdi
movq 0x18(%r15), %rsi
movq %rbx, %rdx
callq 0x14b992
testl %eax, %eax
jne 0x182ca9
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x572fe
callq 0x5736c
callq 0x57335
// File: /workspace/github_c_makefile_star2_O1/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 0x182bb0
movq %rax, %rdi
xorl %esi, %esi
callq 0x16abec
movq %rax, %r13
callq 0x182bb0
movq %rax, %rdi
movq %r13, %rsi
callq 0x16ae64
movq %rax, %rbp
movq %rbx, %rdi
callq 0x16ac58
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 0x182ee4
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_O1/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 0xe6a03
cmpq $0x0, 0x346b4a(%rip)    # 0x4c98c8
jne 0x182db3
movq $0x0, (%rsp)
leaq 0x32(%rip), %rsi        # 0x182dc1
leaq 0x9d(%rip), %rcx        # 0x182e33
leaq 0xe6(%rip), %r8         # 0x182e83
movl $0xb0, %edi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x346b15(%rip)    # 0x4c98c8
callq 0xe6a19
movq 0x346b09(%rip), %rax    # 0x4c98c8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x182d70
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq 0xa0(%rax), %rdi
callq 0xe9120
movq 0x98(%rbx), %rdi
callq 0xe9ff6
movq 0x90(%rbx), %rdi
callq 0xe9ff6
movq 0x88(%rbx), %rdi
callq 0xe9ff6
movq 0x80(%rbx), %rdi
callq 0xe9ff6
movq 0x78(%rbx), %rdi
callq 0xe9ff6
movq 0x70(%rbx), %rdi
callq 0xe9ff6
movq 0xa8(%rbx), %rdi
popq %rbx
jmp 0x1222cb
// File: /workspace/github_c_makefile_star2_O1/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 0x182e52
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x182e7e
callq 0x182d70
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
leaq 0x40e(%rip), %rdx       # 0x183277
movq %r14, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x149fca
callq 0x573a3
// File: /workspace/github_c_makefile_star2_O1/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 0x182ea1
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x182edf
callq 0x182d70
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
incq 0x10(%rax)
movq %rbx, %rdi
callq 0x14b8df
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x117813
addq %rax, 0x68(%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x573dc
// File: /workspace/github_c_makefile_star2_O1/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 0x182d70
movq %rax, %rdi
callq 0x16aef0
movq %rax, %rbx
callq 0x182d70
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %r14
testl %r15d, %r15d
je 0x182f34
callq 0xe99dc
movq %rax, 0x70(%r14)
testb %bpl, %bpl
je 0x182f42
callq 0xe99dc
movq %rax, 0x78(%r14)
testb %r13b, %r13b
je 0x182f53
callq 0xe99dc
movq %rax, 0x80(%r14)
testb %r12b, %r12b
je 0x182f64
callq 0xe99dc
movq %rax, 0x88(%r14)
cmpb $0x0, (%rsp)
je 0x182f76
callq 0xe99dc
movq %rax, 0x90(%r14)
movb 0x40(%rsp), %bpl
cmpb $0x0, 0x4(%rsp)
je 0x182f8e
callq 0xe99dc
movq %rax, 0x98(%r14)
callq 0x121fd0
movq %rax, 0xa8(%r14)
testb %bpl, %bpl
je 0x182fab
callq 0xe8d9c
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_O1/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 0x18359a
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1835fc
testq %r14, %r14
je 0x1835f7
testq %rbx, %rbx
je 0x1835f7
leaq 0x21a693(%rip), %rsi    # 0x39dc3e
movq %r14, %rdi
callq 0x149d45
testb %al, %al
je 0x1835bd
incq 0x58(%rbx)
jmp 0x1835ed
leaq 0x208218(%rip), %rsi    # 0x38b7dc
movq %r14, %rdi
callq 0x149d45
testb %al, %al
je 0x1835ed
movq %r14, %rdi
callq 0x14b8df
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
callq 0x117813
addq %rax, 0x60(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x57565
callq 0x5752e
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 $0x818, %rsp            # imm = 0x818
movq %r9, 0x10(%rsp)
testq %rdi, %rdi
je 0x1867df
testq %rdx, %rdx
je 0x1867df
movq %rcx, %r12
movq %rsi, %r14
leaq -0x1(%rcx), %rax
cmpq %rsi, %rax
jae 0x1867cd
movq %r8, %rbp
movq %rdi, %rsi
movdqa 0x1db3d3(%rip), %xmm0   # 0x361a70
xorl %edi, %edi
movdqa 0x1db3d9(%rip), %xmm1   # 0x361a80
movdqa 0x2185c1(%rip), %xmm2   # 0x39ec70
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movdqa 0x1db3d4(%rip), %xmm4   # 0x361a90
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, %r9d
testb $0x1, %r9b
je 0x1866e9
movq %r12, 0x20(%rsp,%rdi,8)
pextrw $0x4, %xmm5, %r9d
testb $0x1, %r9b
je 0x1866fa
movq %r12, 0x28(%rsp,%rdi,8)
addq $0x2, %rdi
paddq %xmm4, %xmm0
cmpq $0x100, %rdi            # imm = 0x100
jne 0x1866bc
testq %rax, %rax
je 0x186727
movq %rdx, %rdi
movsbq (%rdi), %r9
movl %r9d, %r9d
movq %rax, 0x20(%rsp,%r9,8)
incq %rdi
decq %rax
jne 0x186713
subq %r12, %r14
leaq -0x1(%rsi), %rax
movq %rax, 0x18(%rsp)
leaq (%rsi,%r12), %r13
decq %r13
testq %r12, %r12
sete %r10b
addq $-0x2, %rsi
movq %rsi, (%rsp)
xorl %ebx, %ebx
movq %rdx, 0x8(%rsp)
movl %r10d, %eax
testq %r12, %r12
je 0x186794
movq 0x18(%rsp), %rax
addq %rbx, %rax
movb (%rax,%r12), %sil
movl %r10d, %eax
cmpb -0x1(%rdx,%r12), %sil
jne 0x186794
movq (%rsp), %rax
leaq (%rax,%rbx), %r11
movq %r12, %r15
cmpq $0x1, %r15
sete %al
je 0x186794
movb (%r11,%r15), %sil
leaq -0x1(%r15), %rdi
cmpb -0x2(%rdx,%r15), %sil
movq %rdi, %r15
je 0x186779
testq %rbp, %rbp
sete %sil
xorb $0x1, %al
orb %sil, %al
jne 0x1867bb
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
movl %r10d, %r15d
callq *%rbp
movl %r15d, %r10d
movq 0x8(%rsp), %rdx
testb %al, %al
jne 0x1867cd
movsbq (%r13,%rbx), %rax
movl %eax, %eax
addq 0x20(%rsp,%rax,8), %rbx
cmpq %r14, %rbx
jbe 0x186750
addq $0x818, %rsp            # imm = 0x818
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5825e
// File: /workspace/github_c_makefile_star2_O1/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 0x186ab0
testq %rbx, %rbx
je 0x186ab0
leaq -0x1(%r15), %rbp
cmpq (%rsp), %rbp
jae 0x186a9e
testq %r15, %r15
je 0x1869f9
xorl %r12d, %r12d
movsbq (%rbx,%r12), %rax
movl %eax, %eax
cmpq $0x0, 0x10(%rsp,%rax,8)
jne 0x1869dd
movq %r15, %rdi
callq 0xd90d0
movsbq (%rbx,%r12), %rcx
movl %ecx, %ecx
movq %rax, 0x10(%rsp,%rcx,8)
movsbq (%rbx,%r12), %rax
movl %eax, %eax
movq 0x10(%rsp,%rax,8), %rdi
movq %r12, %rsi
callq 0xd913c
incq %r12
cmpq %r12, %r15
jne 0x1869ba
movq %r15, %rdi
callq 0xd90d0
movq %rax, %rbx
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0xd93be
movq %rbx, %rdi
xorl %esi, %esi
callq 0xd913c
movsbq (%r13,%r12), %rax
movl %eax, %eax
movq 0x10(%rsp,%rax,8), %rsi
movq %rbx, %rdi
testq %rsi, %rsi
je 0x186a35
callq 0xd933c
jmp 0x186a3a
callq 0xd942f
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xd94c7
testq %r14, %r14
je 0x186a63
testb %al, %al
je 0x186a63
movq %r12, %rdi
subq %r15, %rdi
incq %rdi
movq 0x8(%rsp), %rsi
callq *%r14
testb %al, %al
jne 0x186a6c
incq %r12
cmpq (%rsp), %r12
jb 0x186a07
xorl %r14d, %r14d
movq 0x10(%rsp,%r14,8), %rdi
callq 0xd97e0
incq %r14
cmpq $0xff, %r14
jne 0x186a6f
movq %rbx, %rdi
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd97e0
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x582cc
// File: /workspace/github_c_makefile_star2_O1/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 0x186b43
movq %rdx, %r12
testq %rdx, %rdx
je 0x186b43
movq %rcx, %r15
movq %rsi, %r13
leaq -0x1(%rcx), %rax
cmpq %rsi, %rax
jae 0x186b34
movq %r8, %r14
movq %rdi, %rbp
subq %r15, %r13
xorl %ebx, %ebx
testq %r15, %r15
je 0x186b0c
leaq (%rbx,%rbp), %rcx
xorl %eax, %eax
movb (%rcx,%rax), %dl
cmpb (%r12,%rax), %dl
jne 0x186b0e
incq %rax
cmpq %rax, %r15
jne 0x186af6
movq %r15, %rax
jmp 0x186b0e
xorl %eax, %eax
testq %r14, %r14
sete %cl
cmpq %r15, %rax
setne %al
orb %cl, %al
jne 0x186b2c
movq %rbx, %rdi
movq (%rsp), %rsi
callq *%r14
testb %al, %al
jne 0x186b34
incq %rbx
cmpq %r13, %rbx
jbe 0x186aeb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x58305