LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_add_stream.c
// Function: gt_sequence_node_add_stream_class
const GtNodeStreamClass* gt_sequence_node_add_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSequenceNodeAddStream),
                                   sequence_node_add_stream_free,
                                   sequence_node_add_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x34aaae(%rip)    # 0x4be870
jne 0x173de3
leaq 0x26(%rip), %rsi        # 0x173df1
leaq 0x5b(%rip), %rdx        # 0x173e2d
movl $0x40, %edi
callq 0x162d34
movq %rax, 0x34aa8d(%rip)    # 0x4be870
callq 0xe2545
movq 0x34aa81(%rip), %rax    # 0x4be870
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_add_stream.c
// Function: sequence_node_add_stream_free
static void sequence_node_add_stream_free(GtNodeStream *ns)
{
  GtSequenceNodeAddStream *fs = gt_sequence_node_add_stream_cast(ns);
  gt_node_visitor_delete(fs->collect_vis);
  gt_cstr_table_delete(fs->seqid_table);
  gt_str_array_delete(fs->seqids);
  gt_node_stream_delete(fs->in_stream);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x173db4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x1632f2
movq 0x20(%rbx), %rdi
callq 0xe4c43
movq 0x28(%rbx), %rdi
callq 0x11c144
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x162dee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_add_stream.c
// Function: gt_sequence_node_add_stream_new
GtNodeStream* gt_sequence_node_add_stream_new(GtNodeStream *in_stream,
                                              GtRegionMapping *rm,
                                              GT_UNUSED GtError *err)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sequence_node_add_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtSequenceNodeAddStream *s = gt_sequence_node_add_stream_cast(ns);
  gt_assert(in_stream);
  s->rm = rm;
  s->in_stream = gt_node_stream_ref(in_stream);
  s->seqid_table = gt_cstr_table_new();
  s->seqids = NULL;
  s->cur_seqid = 0;
  s->collect_vis = gt_collect_ids_visitor_new(s->seqid_table);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x173db4
movq %rax, %rbx
movq %r14, %rdi
callq 0x162fe4
movzbl %al, %esi
movq %rbx, %rdi
callq 0x162d6c
movq %rax, %rbx
callq 0x173db4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
testq %r14, %r14
je 0x174056
movq %rax, %r12
movq %r15, 0x30(%rax)
movq %r14, %rdi
callq 0x162dd8
movq %rax, 0x10(%r12)
callq 0xe48d0
movq %rax, 0x20(%r12)
xorl %ecx, %ecx
movq %rcx, 0x28(%r12)
movq %rcx, 0x38(%r12)
movq %rax, %rdi
callq 0x129320
movq %rax, 0x18(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x544c2
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_stream.c
// Function: gt_sequence_node_out_stream_class
const GtNodeStreamClass* gt_sequence_node_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSequenceNodeOutStream),
                                   sequence_node_out_stream_free,
                                   sequence_node_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x34a80e(%rip)    # 0x4be878
jne 0x17408b
leaq 0x26(%rip), %rsi        # 0x174099
leaq 0x49(%rip), %rdx        # 0x1740c3
movl $0x20, %edi
callq 0x162d34
movq %rax, 0x34a7ed(%rip)    # 0x4be878
callq 0xe2545
movq 0x34a7e1(%rip), %rax    # 0x4be878
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_stream.c
// Function: sequence_node_out_stream_next
static int sequence_node_out_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                         GtError *err)
{
  GtSequenceNodeOutStream *fs;
  int had_err;
  gt_error_check(err);
  fs = gt_sequence_node_out_stream_cast(ns);

  /* we still have nodes in the buffer */
  if (gt_sequence_node_out_visitor_node_buffer_size(
                                               fs->sequence_node_out_visitor)) {
    /* return one of them */
    *gn = gt_sequence_node_out_visitor_get_node(fs->sequence_node_out_visitor);
    return 0;
  }

  /* no nodes in the buffer -> get new nodes */
  while (!(had_err = gt_node_stream_next(fs->in_stream, gn, err)) && *gn) {
    gt_assert(*gn && !had_err);
    had_err = gt_genome_node_accept(*gn, fs->sequence_node_out_visitor, err);
    if (had_err) {
      /* we own the node -> delete it */
      gt_genome_node_delete(*gn);
      *gn = NULL;
      break;
    }
    if (gt_sequence_node_out_visitor_node_buffer_size(
                                               fs->sequence_node_out_visitor)) {
     *gn = gt_sequence_node_out_visitor_get_node(fs->sequence_node_out_visitor);
     return 0;
    }
  }

  /* either we have an error or no new node */
  gt_assert(had_err || !*gn);
  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 0x1740e8
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x17416b
callq 0x17405c
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x174545
testq %rax, %rax
jne 0x17413a
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x162e68
testl %eax, %eax
jne 0x174155
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x174159
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x14472c
testl %eax, %eax
jne 0x17415d
movq 0x18(%r15), %rdi
jmp 0x1740ff
movq 0x18(%r15), %rdi
callq 0x174563
xorl %ebp, %ebp
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
jmp 0x174148
xorl %ebp, %ebp
jmp 0x174148
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x1451a0
xorl %eax, %eax
jmp 0x174145
callq 0x544f9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_stream.c
// Function: gt_sequence_node_out_stream_new
GtNodeStream* gt_sequence_node_out_stream_new(GtNodeStream *in_stream,
                                              GtFile *outfile,
                                              GT_UNUSED GtError *err)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sequence_node_out_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtSequenceNodeOutStream *s = gt_sequence_node_out_stream_cast(ns);
  gt_assert(in_stream);
  s->in_stream = gt_node_stream_ref(in_stream);
  s->sequence_node_out_visitor =
    gt_sequence_node_out_visitor_new(outfile);
  if  (!s->sequence_node_out_visitor) {
    gt_node_stream_delete(ns);
    return NULL;
  }
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x17405c
movq %rax, %r14
movq %r15, %rdi
callq 0x162fe4
movzbl %al, %esi
movq %r14, %rdi
callq 0x162d6c
movq %rax, %r14
callq 0x17405c
movq %rax, %rdi
movq %r14, %rsi
callq 0x162ff7
testq %r15, %r15
je 0x1741ed
movq %rax, %r12
movq %r15, %rdi
callq 0x162dd8
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x1744e8
movq %rax, 0x18(%r12)
testq %rax, %rax
jne 0x1741de
movq %r14, %rdi
callq 0x162dee
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x54530
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: gt_sequence_node_out_visitor_class
const GtNodeVisitorClass* gt_sequence_node_out_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSequenceNodeOutVisitor),
                                    sequence_node_out_visitor_free,
                                    sequence_node_out_visitor_comment_node,
                                    sequence_node_out_visitor_feature_node,
                                    sequence_node_out_visitor_region_node,
                                    sequence_node_out_visitor_sequence_node,
                                    sequence_node_out_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc,
                                           sequence_node_out_visitor_meta_node);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x34a67e(%rip)    # 0x4be880
jne 0x174252
leaq 0x229(%rip), %rax       # 0x174434
movq %rax, (%rsp)
leaq 0x4a(%rip), %rsi        # 0x174260
leaq 0x61(%rip), %rdx        # 0x17427e
leaq 0xb4(%rip), %rcx        # 0x1742d8
leaq 0x107(%rip), %r8        # 0x174332
leaq 0x15a(%rip), %r9        # 0x17438c
movl $0x30, %edi
callq 0x163010
movq %rax, 0x34a63d(%rip)    # 0x4be880
leaq 0x244(%rip), %rsi       # 0x17448e
movq %rax, %rdi
callq 0x163070
callq 0xe2545
movq 0x34a622(%rip), %rax    # 0x4be880
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_comment_node
static int sequence_node_out_visitor_comment_node(GtNodeVisitor *nv,
                                                   GtCommentNode *cn,
                                                   GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && cn);

  gt_queue_add(v->node_buffer, cn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1741f4
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
testq %r15, %r15
je 0x1742b0
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1742d3
testq %rbx, %rbx
je 0x1742ce
testq %r14, %r14
je 0x1742ce
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x10d65b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5459e
callq 0x54567
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_feature_node
static int sequence_node_out_visitor_feature_node(GtNodeVisitor *nv,
                                                  GtFeatureNode *fn,
                                                  GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && fn);

  gt_queue_add(v->node_buffer, fn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1741f4
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
testq %r15, %r15
je 0x17430a
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x17432d
testq %rbx, %rbx
je 0x174328
testq %r14, %r14
je 0x174328
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x10d65b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5460c
callq 0x545d5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_region_node
static int sequence_node_out_visitor_region_node(GtNodeVisitor *nv,
                                                 GtRegionNode *rn,
                                                 GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && rn);

  gt_queue_add(v->node_buffer, rn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1741f4
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
testq %r15, %r15
je 0x174364
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x174387
testq %rbx, %rbx
je 0x174382
testq %r14, %r14
je 0x174382
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x10d65b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5467a
callq 0x54643
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_sequence_node
static int sequence_node_out_visitor_sequence_node(GtNodeVisitor *nv,
                                                   GtSequenceNode *sn,
                                                   GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  GT_UNUSED GtFeatureNode *node;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && sn);

  gt_fasta_show_entry(gt_sequence_node_get_description(sn),
                      gt_sequence_node_get_sequence(sn),
                      gt_sequence_node_get_sequence_length(sn),
                      v->width, v->outfile);

  if (v->keep_sequence_nodes)
    gt_queue_add(v->node_buffer, sn);
  else
    gt_genome_node_delete((GtGenomeNode*) sn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1741f4
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
testq %r15, %r15
je 0x1743c1
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x17442f
testq %rbx, %rbx
je 0x17442a
testq %r14, %r14
je 0x17442a
movq %rbx, %rdi
callq 0x173d62
movq %rax, %r15
movq %rbx, %rdi
callq 0x173d76
movq %rax, %r12
movq %rbx, %rdi
callq 0x173d8a
movq 0x18(%r14), %r8
movq 0x20(%r14), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xfe000
cmpb $0x1, 0x28(%r14)
jne 0x174414
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x10d65b
jmp 0x17441c
movq %rbx, %rdi
callq 0x1451a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x546e8
callq 0x546b1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_eof_node
static int sequence_node_out_visitor_eof_node(GtNodeVisitor *nv,
                                              GtEOFNode *en,
                                              GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && en);

  gt_queue_add(v->node_buffer, en);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1741f4
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
testq %r15, %r15
je 0x174466
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x174489
testq %rbx, %rbx
je 0x174484
testq %r14, %r14
je 0x174484
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x10d65b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x54756
callq 0x5471f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_meta_node
static int sequence_node_out_visitor_meta_node(GtNodeVisitor *nv,
                                               GtMetaNode *mn,
                                               GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && mn);

  gt_queue_add(v->node_buffer, mn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1741f4
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
testq %r15, %r15
je 0x1744c0
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1744e3
testq %rbx, %rbx
je 0x1744de
testq %r14, %r14
je 0x1744de
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x10d65b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x547c6
callq 0x5478d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: gt_sequence_node_out_visitor_new
GtNodeVisitor* gt_sequence_node_out_visitor_new(GtFile *outfile)
{
  GtNodeVisitor *nv =
                   gt_node_visitor_create(gt_sequence_node_out_visitor_class());
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  v->outfile = outfile;
  v->width = 80;
  v->keep_sequence_nodes = false;
  v->node_buffer = gt_queue_new();
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1741f4
movq %rax, %rdi
callq 0x163080
movq %rax, %r14
callq 0x1741f4
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r15
movq %rbx, 0x18(%rax)
movq $0x50, 0x20(%rax)
movb $0x0, 0x28(%rax)
callq 0x10d640
movq %rax, 0x10(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/set_source_visitor.c
// Function: gt_set_source_visitor_new
GtNodeVisitor *gt_set_source_visitor_new(GtStr *newsource)
{
  GtNodeVisitor *nv;
  gt_assert(newsource);
  nv = gt_node_visitor_create(gt_set_source_visitor_class());
  GtSetSourceVisitor *ssv = set_source_visitor_cast(nv);
  ssv->newsource = gt_str_ref(newsource);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1745c9
movq %rdi, %rbx
callq 0x1745ce
movq %rax, %rdi
callq 0x163080
movq %rax, %r14
callq 0x1745ce
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r15
movq %rbx, %rdi
callq 0x11b1f3
movq %rax, 0x10(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x54838
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/set_source_visitor.c
// Function: gt_set_source_visitor_class
const GtNodeVisitorClass *gt_set_source_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc)
  {
    nvc = gt_node_visitor_class_new(sizeof (GtSetSourceVisitor),
                                    set_source_visitor_free,
                                    NULL,
                                    set_source_visitor_visit_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x34a2ac(%rip)    # 0x4be888
jne 0x17460d
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x17461b
leaq 0x45(%rip), %rcx        # 0x174639
movl $0x18, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x34a27b(%rip)    # 0x4be888
callq 0xe2545
movq 0x34a26f(%rip), %rax    # 0x4be888
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/set_source_visitor.c
// Function: set_source_visitor_visit_feature_node
static int set_source_visitor_visit_feature_node(GtNodeVisitor *nv,
                                                 GtFeatureNode *fn,
                                                 GT_UNUSED GtError *error)
{
  GtSetSourceVisitor *ssv;
  gt_error_check(error);
  ssv = set_source_visitor_cast(nv);

  GtFeatureNode *current;
  GtFeatureNodeIterator *iter = gt_feature_node_iterator_new(fn);
  for (current  = gt_feature_node_iterator_next(iter);
       current != NULL;
       current  = gt_feature_node_iterator_next(iter))
  {
    gt_feature_node_set_source(current, ssv->newsource);
  }
  gt_feature_node_iterator_delete(iter);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x174654
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1746a2
callq 0x1745ce
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %rbx
movq %r14, %rdi
callq 0x143f54
movq %rax, %r14
movq %rax, %rdi
callq 0x1440ea
testq %rax, %rax
je 0x174690
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x141fb5
movq %r14, %rdi
jmp 0x174675
movq %r14, %rdi
callq 0x14417c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5486f
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/shredder.c
// Function: gt_shredder_new
GtShredder* gt_shredder_new(GtBioseq *bioseq, GtUword minlength,
                                       GtUword maxlength)
{
  GtShredder *shredder = gt_calloc(1, sizeof *shredder);
  gt_assert(bioseq && minlength && minlength <= maxlength);
  shredder->bioseq = bioseq;
  shredder->minlength = minlength;
  shredder->maxlength = maxlength;
  shredder->sample_probability = 1.0;
  return shredder;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x21ea53(%rip), %rdx    # 0x393110
movl $0x1, %edi
movl $0x38, %esi
movl $0x23, %ecx
callq 0x10436a
testq %r15, %r15
je 0x1746fe
leaq -0x1(%r14), %rcx
cmpq %rbx, %rcx
jae 0x1746fe
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x30(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x548a6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/shredder.c
// Function: gt_shredder_shred
char* gt_shredder_shred(GtShredder *shredder, GtUword *fragment_offset,
                        GtUword *fragment_length, GtStr *desc)
{
  char *frag;
  gt_assert(shredder && fragment_length);
  while ((frag = generate_fragment(shredder, fragment_offset, fragment_length,
                                   desc))) {
    if (shredder->sample_probability == 1.0 ||
        gt_rand_0_to_1() <= shredder->sample_probability) {
      return frag;
    } else gt_free(frag);
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rdi, %rdi
je 0x1748cb
movq %rdx, %r14
testq %rdx, %rdx
je 0x1748cb
movq %rcx, %rbx
movq %rdi, %r12
movq (%r12), %rdi
movq 0x20(%r12), %r15
callq 0xd4fc8
cmpq %rax, %r15
jae 0x1748ac
movq (%r12), %rdi
movq 0x20(%r12), %rsi
callq 0xd4ba3
movq %rax, %r15
movq 0x10(%r12), %rcx
movq %rcx, %rdi
subq 0x8(%r12), %rdi
jne 0x1747be
xorl %eax, %eax
jmp 0x1747c8
callq 0x105d85
movq 0x8(%r12), %rcx
addq %rax, %rcx
jb 0x1748c1
movq 0x28(%r12), %rax
leaq (%rax,%rcx), %rdx
movq %r15, %rbp
subq %rax, %rbp
cmpq %r15, %rdx
cmovbeq %rcx, %rbp
movq (%rsp), %rcx
movq %rax, (%rcx)
movq %rbp, (%r14)
movq %rbx, %rdi
callq 0x11b132
movq (%r12), %rdi
movq 0x20(%r12), %rsi
callq 0xd4bb7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11acf3
movq 0x28(%r12), %rdx
leaq (%rdx,%rbp), %rcx
cmpq %r15, %rcx
ja 0x1748c6
movq (%r12), %rdi
movq 0x20(%r12), %rsi
decq %rcx
callq 0xd4d09
movq %rax, %r13
movq 0x28(%r12), %rcx
leaq (%rcx,%rbp), %rax
cmpq %r15, %rax
jne 0x17484f
incq 0x20(%r12)
xorl %eax, %eax
jmp 0x174864
movq 0x18(%r12), %rdx
cmpq %rdx, %rbp
jbe 0x17485e
subq %rdx, %rax
jmp 0x174864
incq %rcx
movq %rcx, %rax
movq %rax, 0x28(%r12)
testq %r13, %r13
je 0x1748ac
movsd 0x30(%r12), %xmm0
ucomisd 0x1d19ab(%rip), %xmm0   # 0x346228
jne 0x174881
jnp 0x1748af
callq 0x105e4d
movsd 0x30(%r12), %xmm1
ucomisd %xmm0, %xmm1
jae 0x1748af
movq %r13, %rdi
leaq 0x21e873(%rip), %rsi    # 0x393110
movl $0x72, %edx
callq 0x1045eb
jmp 0x174783
xorl %r13d, %r13d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x549f0
callq 0x549b9
callq 0x54982
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/snp_annotator_stream.c
// Function: gt_snp_annotator_stream_class
const GtNodeStreamClass* gt_snp_annotator_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSNPAnnotatorStream),
                                   snp_annotator_stream_free,
                                   snp_annotator_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x349fb2(%rip)    # 0x4be890
jne 0x1748ff
leaq 0x26(%rip), %rsi        # 0x17490d
leaq 0x12c(%rip), %rdx       # 0x174a1a
movl $0x58, %edi
callq 0x162d34
movq %rax, 0x349f91(%rip)    # 0x4be890
callq 0xe2545
movq 0x349f85(%rip), %rax    # 0x4be890
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/snp_annotator_stream.c
// Function: snp_annotator_stream_free
static void snp_annotator_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtSNPAnnotatorStream *sas;
  if (!ns) return;
  sas = gt_snp_annotator_stream_cast(ns);
  gt_region_mapping_delete(sas->rmap);
  while (gt_queue_size(sas->snps) > 0) {
    gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->snps));
  }
  while (gt_queue_size(sas->outqueue) > 0) {
    gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->outqueue));
  }
  for (i = 0; i < gt_array_size(sas->instreams); i++) {
    gt_node_stream_delete(*(GtNodeStream**) gt_array_get(sas->instreams, i));
  }
  for (i = 0; i < gt_array_size(sas->cur_gene_set); i++) {
    gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(sas->cur_gene_set, i));
  }
  gt_array_delete(sas->cur_gene_set);
  gt_node_stream_delete(sas->merge_stream);
  gt_array_delete(sas->instreams);
  gt_queue_delete(sas->snps);
  gt_queue_delete(sas->outqueue);
}

// Assembly:
testq %rdi, %rdi
je 0x174a19
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1748d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x40(%rax), %rdi
callq 0x16d652
movq 0x48(%rbx), %rdi
callq 0x10d7ac
testq %rax, %rax
je 0x17496b
movq 0x48(%rbx), %rdi
callq 0x10d74a
movq %rax, %rdi
callq 0x1451a0
jmp 0x174939
movq 0x50(%rbx), %rdi
callq 0x10d74a
movq %rax, %rdi
callq 0x1451a0
movq 0x50(%rbx), %rdi
callq 0x10d7ac
testq %rax, %rax
jne 0x17495a
movq 0x28(%rbx), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x1749af
xorl %r14d, %r14d
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x162dee
incq %r14
movq 0x28(%rbx), %rdi
callq 0xd24e0
cmpq %rax, %r14
jb 0x17498a
movq 0x20(%rbx), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x1749e5
xorl %r14d, %r14d
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x1451a0
incq %r14
movq 0x20(%rbx), %rdi
callq 0xd24e0
cmpq %rax, %r14
jb 0x1749c0
movq 0x20(%rbx), %rdi
callq 0xd2938
movq 0x10(%rbx), %rdi
callq 0x162dee
movq 0x28(%rbx), %rdi
callq 0xd2938
movq 0x48(%rbx), %rdi
callq 0x10dc23
movq 0x50(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10dc23
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/snp_annotator_stream.c
// Function: gt_snp_annotator_stream_new
GtNodeStream* gt_snp_annotator_stream_new(GtNodeStream *gvf_stream,
                                          GtNodeStream *gff_stream,
                                          GtTransTable *trans_table,
                                          GtRegionMapping *rmap)
{
  GtSNPAnnotatorStream *sas;
  GtNodeStream *ns;
  gt_assert(gvf_stream && gff_stream && rmap);
  ns = gt_node_stream_create(gt_snp_annotator_stream_class(), true);
  sas = gt_snp_annotator_stream_cast(ns);
  sas->instreams = gt_array_new(sizeof (GtNodeStream*));
  (void) gt_node_stream_ref(gvf_stream);
  gt_array_add(sas->instreams, gvf_stream);
  (void) gt_node_stream_ref(gff_stream);
  gt_array_add(sas->instreams, gff_stream);
  sas->cur_gene_set = gt_array_new(sizeof (GtFeatureNode*));
  sas->merge_stream = gt_merge_stream_new(sas->instreams);
  sas->rmap = gt_region_mapping_ref(rmap);
  sas->cur_gene_range.start =
    sas->cur_gene_range.end = GT_UNDEF_UWORD;
  sas->snps = gt_queue_new();
  sas->outqueue = gt_queue_new();
  sas->tt = trans_table;
  return ns;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
testq %rdi, %rdi
je 0x174e5d
movq %rsi, %r13
testq %rsi, %rsi
je 0x174e5d
movq %rcx, %r14
testq %rcx, %rcx
je 0x174e5d
movq %rdx, %rbx
movq %rdi, %rbp
callq 0x1748d0
movq %rax, %rdi
movl $0x1, %esi
callq 0x162d6c
movq %rax, %r15
callq 0x1748d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
movq %rax, %r12
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x28(%r12)
movq %rbp, %rdi
callq 0x162dd8
movq 0x28(%r12), %rdi
leaq 0x10(%rsp), %rsi
movl $0x8, %edx
callq 0xd2410
movq %r13, %rdi
callq 0x162dd8
movq 0x28(%r12), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0xd2410
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x20(%r12)
movq 0x28(%r12), %rdi
callq 0x16167d
movq %rax, 0x10(%r12)
movq %r14, %rdi
callq 0x16d803
movq %rax, 0x40(%r12)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x30(%r12)
callq 0x10d640
movq %rax, 0x48(%r12)
callq 0x10d640
movq %rax, 0x50(%r12)
movq %rbx, 0x18(%r12)
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x54a97
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/snp_annotator_visitor.c
// Function: gt_snp_annotator_visitor_class
const GtNodeVisitorClass* gt_snp_annotator_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSNPAnnotatorVisitor),
                                    snp_annotator_visitor_free,
                                    NULL,
                                    snp_annotator_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x34988a(%rip)    # 0x4be898
jne 0x17503f
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x17504d
leaq 0x6f(%rip), %rcx        # 0x175095
movl $0x58, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x349859(%rip)    # 0x4be898
callq 0xe2545
movq 0x34984d(%rip), %rax    # 0x4be898
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/snp_annotator_visitor.c
// Function: snp_annotator_visitor_free
static void snp_annotator_visitor_free(GtNodeVisitor *nv)
{
  GtSNPAnnotatorVisitor *sav;
  if (!nv) return;
  sav = snp_annotator_visitor_cast(nv);
  gt_genome_node_delete((GtGenomeNode*) sav->gene);
  if (sav->own_tt)
    gt_trans_table_delete(sav->tt);
  gt_region_mapping_delete(sav->rmap);
  gt_hashmap_delete(sav->rnaseqs);
}

// Assembly:
testq %rdi, %rdi
je 0x175094
pushq %rbx
movq %rdi, %rbx
callq 0x175000
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x1451a0
cmpb $0x1, 0x30(%rbx)
jne 0x175081
movq 0x28(%rbx), %rdi
callq 0x11e318
movq 0x18(%rbx), %rdi
callq 0x16d652
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x10109b
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_results_new
GtSpecResults *gt_spec_results_new(void)
{
  GtSpecResults *spec_results;
  spec_results = gt_calloc(1, sizeof (GtSpecResults));
  spec_results->feature_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                                 (GtFree) gt_hashmap_delete);
  spec_results->meta_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                              (GtFree) gt_spec_aspect_delete);
  spec_results->sequence_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                               (GtFree) gt_spec_aspect_delete);
  spec_results->region_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                               (GtFree) gt_spec_aspect_delete);
  spec_results->comment_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                               (GtFree) gt_spec_aspect_delete);
  spec_results->warnings = gt_str_array_new();
  spec_results->has_runtime_errors = spec_results->has_failures = false;
  return spec_results;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x21d7a1(%rip), %rdx    # 0x39357c
movl $0x1, %edi
movl $0x58, %esi
movl $0x98, %ecx
callq 0x10436a
movq %rax, %rbx
leaq -0x74d5e(%rip), %rdx    # 0x10109b
movl $0x1, %edi
xorl %esi, %esi
callq 0x1008fc
movq %rax, (%rbx)
leaq 0x66(%rip), %r14        # 0x175e75
movl $0x1, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1008fc
movq %rax, 0x8(%rbx)
movl $0x1, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1008fc
movq %rax, 0x20(%rbx)
movl $0x1, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1008fc
movq %rax, 0x10(%rbx)
movl $0x1, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x1008fc
movq %rax, 0x18(%rbx)
callq 0x11be10
movq %rax, 0x50(%rbx)
movw $0x0, 0x2d(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_aspect_delete
static void gt_spec_aspect_delete(GtSpecAspect *sa)
{
  if (!sa) return;
  gt_str_delete(sa->name);
  gt_hashmap_delete(sa->aspect_node_results);
  gt_free(sa);
}

// Assembly:
testq %rdi, %rdi
je 0x175ea4
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11bdbf
movq (%rbx), %rdi
callq 0x10109b
leaq 0x21d6e6(%rip), %rsi    # 0x39357c
movq %rbx, %rdi
movl $0x92, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_aspect_new
static GtSpecAspect* gt_spec_aspect_new(const char *name)
{
  GtSpecAspect *sa;
  gt_assert(name);

  sa = gt_calloc(1, sizeof (*sa));
  sa->name = gt_str_new_cstr(name);
  sa->last_node = NULL;
  sa->aspect_node_results= gt_hashmap_new(GT_HASH_DIRECT,
                                    (GtFree) gt_genome_node_delete,
                                    (GtFree) gt_spec_aspect_node_result_delete);

  return sa;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x21d334(%rip), %rdx    # 0x39357c
movl $0x1, %edi
movl $0x20, %esi
movl $0x83, %ecx
callq 0x10436a
movq %rax, %r14
movq %rbx, %rdi
callq 0x11acc9
movq %rax, 0x8(%r14)
movq $0x0, 0x10(%r14)
leaq -0x310da(%rip), %rsi    # 0x1451a0
leaq 0x944(%rip), %rdx       # 0x176bc5
xorl %edi, %edi
callq 0x1008fc
movq %rax, (%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_results_make_feature_model
static int gt_spec_results_make_feature_model(void *key, void *value,
                                              void *data,
                                                         GT_UNUSED GtError *err)
{
  const char *type = (const char*) key;
  GtSpecResultsReportInfo *info = (GtSpecResultsReportInfo*) data;
  lua_pushstring(info->L, type);
  lua_newtable(info->L);
  gt_hashmap_foreach((GtHashmap*) value, gt_spec_results_make_aspect_model,
                     info, NULL);
  lua_rawset(info->L, -3);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq 0x18(%rdx), %rdi
callq 0x2243ba
movq 0x18(%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x224be0
leaq 0x25(%rip), %rsi        # 0x1768ce
movq %r14, %rdi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x100bc9
movq 0x18(%rbx), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224fd4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_results_lua_print
static int gt_spec_results_lua_print(lua_State* L) {
    GtFile *outfile;
    int i = 0;
    gt_assert(L);

    lua_pushlightuserdata(L, (void *) &spec_resuserdata);
    lua_gettable(L, LUA_REGISTRYINDEX);
    outfile = lua_touserdata(L, -1);

    for (i = 1; i <= lua_gettop(L); i++) {
      if (lua_isstring(L, i)) {
        gt_file_xprintf(outfile, "%s", lua_tostring(L, i));
      }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x176b6c
movq %rdi, %rbx
leaq 0x343700(%rip), %rsi    # 0x4ba1f0
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
movq %rax, %r14
movq %rbx, %rdi
callq 0x2235ac
testl %eax, %eax
jle 0x176b5f
leaq 0x251f84(%rip), %r15    # 0x3c8aa9
xorl %ebp, %ebp
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x223b1f
testl %eax, %eax
je 0x176b53
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x223ea8
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
movq %rbx, %rdi
callq 0x2235ac
cmpl %eax, %ebp
jl 0x176b27
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x551a7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_results_delete
void gt_spec_results_delete(GtSpecResults *spec_results)
{
  if (!spec_results) return;
  gt_hashmap_delete(spec_results->feature_aspects);
  gt_hashmap_delete(spec_results->meta_aspects);
  gt_hashmap_delete(spec_results->comment_aspects);
  gt_hashmap_delete(spec_results->sequence_aspects);
  gt_hashmap_delete(spec_results->region_aspects);
  gt_str_array_delete(spec_results->warnings);
  gt_free(spec_results);
}

// Assembly:
testq %rdi, %rdi
je 0x176bc4
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x10109b
movq 0x8(%rbx), %rdi
callq 0x10109b
movq 0x18(%rbx), %rdi
callq 0x10109b
movq 0x20(%rbx), %rdi
callq 0x10109b
movq 0x10(%rbx), %rdi
callq 0x10109b
movq 0x50(%rbx), %rdi
callq 0x11c144
leaq 0x21c9c6(%rip), %rsi    # 0x39357c
movq %rbx, %rdi
movl $0x23f, %edx            # imm = 0x23F
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_aspect_node_result_delete
static void gt_spec_aspect_node_result_delete(GtSpecAspectNodeResult *sanr)
{
  if (!sanr) return;
  gt_str_array_delete(sanr->failure_messages);
  gt_str_array_delete(sanr->runtime_error_messages);
  gt_free(sanr);
}

// Assembly:
testq %rdi, %rdi
je 0x176bf4
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11c144
movq 0x8(%rbx), %rdi
callq 0x11c144
leaq 0x21c996(%rip), %rsi    # 0x39357c
movq %rbx, %rdi
movl $0x7b, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_aspect_node_result_new
static GtSpecAspectNodeResult* gt_spec_aspect_node_result_new()
{
  GtSpecAspectNodeResult *sanr;

  sanr = gt_calloc(1, sizeof (*sanr));
  sanr->failure_messages = gt_str_array_new();
  sanr->runtime_error_messages = gt_str_array_new();
  return sanr;
}

// Assembly:
pushq %rbx
leaq 0x21c97f(%rip), %rdx    # 0x39357c
movl $0x1, %edi
movl $0x10, %esi
movl $0x70, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11be10
movq %rax, (%rbx)
callq 0x11be10
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_aspect_count_stats
static int gt_spec_aspect_count_stats(GT_UNUSED void *key, void *value,
                                      void *data, GT_UNUSED GtError *err)
{
  GtSpecAspectNodeResult *sanr = (GtSpecAspectNodeResult*) value;
  GtSpecAspectCountInfo *info = (GtSpecAspectCountInfo*) data;

  if (gt_str_array_size(sanr->runtime_error_messages) > 0) {
    (*info->err)++;
  } else if (gt_str_array_size(sanr->failure_messages) > 0) {
    (*info->fail)++;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rdi
callq 0x11c131
testq %rax, %rax
je 0x176c48
addq $0x8, %rbx
jmp 0x176c55
movq (%r14), %rdi
callq 0x11c131
testq %rax, %rax
je 0x176c5b
movq (%rbx), %rax
incq (%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_visitor.c
// Function: gt_spec_visitor_class
const GtNodeVisitorClass* gt_spec_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSpecVisitor),
                                    spec_visitor_free,
                                    spec_visitor_comment_node,
                                    spec_visitor_feature_node,
                                    spec_visitor_region_node,
                                    spec_visitor_sequence_node,
                                    NULL);
    gt_node_visitor_class_set_meta_node_func(nvc, spec_visitor_meta_node);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x347962(%rip)    # 0x4be8a8
jne 0x176f93
movq $0x0, (%rsp)
leaq 0x4a(%rip), %rsi        # 0x176fa1
leaq 0x85(%rip), %rdx        # 0x176fe3
leaq 0x145(%rip), %rcx       # 0x1770aa
leaq 0x209(%rip), %r8        # 0x177175
leaq 0x2c9(%rip), %r9        # 0x17723c
movl $0x78, %edi
callq 0x163010
movq %rax, 0x347924(%rip)    # 0x4be8a8
leaq 0x378(%rip), %rsi       # 0x177303
movq %rax, %rdi
callq 0x163070
callq 0xe2545
movq 0x347909(%rip), %rax    # 0x4be8a8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_free
static void spec_visitor_free(GtNodeVisitor* nv)
{
  GtSpecVisitor *sv;
  if (!nv) return;
  sv = spec_visitor_cast(nv);
  gt_str_delete(sv->filename);
  lua_close(sv->L);
  gt_hashmap_delete(sv->type_specs);
  gt_array_delete(sv->graph_context);
}

// Assembly:
testq %rdi, %rdi
je 0x176fe2
pushq %rbx
movq %rdi, %rbx
callq 0x176f38
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x226b39
movq 0x20(%rbx), %rdi
callq 0x10109b
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0xd2938
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_comment_node
static int spec_visitor_comment_node(GtNodeVisitor *nv, GtCommentNode *cn,
                                     GtError *err)
{
  int had_err = 0;
  GtSpecVisitor *sv;
  gt_error_check(err);

  sv = spec_visitor_cast(nv);
  if (sv->comment_ref != GT_UNDEF_INT) {
    sv->current_node = (GtGenomeNode*) cn;
    lua_rawgeti(sv->L, LUA_REGISTRYINDEX, sv->comment_ref);
    gt_lua_genome_node_push(sv->L, gt_genome_node_ref((GtGenomeNode*) cn));
    if (lua_pcall(sv->L, 1, 0, 0)) {
      const char *error = lua_tostring(sv->L, -1);
      gt_error_set(err, "%s", error);
      had_err = -1;
    }
  }
  gt_spec_results_add_cc(sv->res);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x177009
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1770a5
callq 0x176f38
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
movl 0x38(%rax), %edx
xorl %ebp, %ebp
movl %edx, %eax
negl %eax
jo 0x177091
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224b36
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x1443a0
movq %r12, %rdi
movq %rax, %rsi
callq 0x186e7d
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22537b
testl %eax, %eax
je 0x177091
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
leaq 0x251a25(%rip), %rsi    # 0x3c8aa9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movq 0x68(%r14), %rdi
callq 0x175ea5
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x551e0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_feature_node
static int spec_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                                     GtError *err)
{
  int had_err = 0;
  GtSpecVisitor *sv;
  GtSpecVisitorNodeTraverseInfo info;
  gt_error_check(err);

  sv = spec_visitor_cast(nv);
  had_err = spec_visitor_process_node(sv, fn, err);
  if (!had_err && gt_feature_node_has_children(fn)) {
    info.sv = sv;
    info.err = err;
    gt_array_add(info.sv->graph_context, fn);
    had_err = gt_feature_node_traverse_direct_children(fn, &info,
                                                       spec_visitor_visit_child,
                                                       err);
    (void) gt_array_pop(info.sv->graph_context);
  }
  gt_spec_results_add_cc(sv->res);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
je 0x1770d9
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x177170
callq 0x176f38
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x177a61
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x177158
movq %r15, %rdi
callq 0x142963
xorl %ebp, %ebp
testb %al, %al
je 0x177158
leaq 0x10(%rsp), %r15
movq %r14, 0x8(%r15)
movq %rbx, (%r15)
movq 0x60(%r14), %rdi
leaq 0x8(%rsp), %r12
movl $0x8, %edx
movq %r12, %rsi
callq 0xd2410
movq (%r12), %rdi
leaq 0x9e4(%rip), %rdx       # 0x177b22
movq %r15, %rsi
movq %rbx, %rcx
callq 0x1438a5
movl %eax, %ebp
movq 0x8(%r15), %rax
movq 0x60(%rax), %rdi
callq 0xd2242
movq 0x68(%r14), %rdi
callq 0x175ea5
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x55219
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_region_node
static int spec_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                    GtError *err)
{
  int had_err = 0;
  GtSpecVisitor *sv;
  gt_error_check(err);

  sv = spec_visitor_cast(nv);
  if (sv->region_ref != GT_UNDEF_INT) {
    sv->current_node = (GtGenomeNode*) rn;
    lua_rawgeti(sv->L, LUA_REGISTRYINDEX, sv->region_ref);
    gt_lua_genome_node_push(sv->L, gt_genome_node_ref((GtGenomeNode*) rn));
    if (lua_pcall(sv->L, 1, 0, 0)) {
      const char *error = lua_tostring(sv->L, -1);
      gt_error_set(err, "%s", error);
      had_err = -1;
    }
  }
  gt_spec_results_add_cc(sv->res);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x17719b
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x177237
callq 0x176f38
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
movl 0x34(%rax), %edx
xorl %ebp, %ebp
movl %edx, %eax
negl %eax
jo 0x177223
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224b36
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x1443a0
movq %r12, %rdi
movq %rax, %rsi
callq 0x186e7d
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22537b
testl %eax, %eax
je 0x177223
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
leaq 0x251893(%rip), %rsi    # 0x3c8aa9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movq 0x68(%r14), %rdi
callq 0x175ea5
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x55252