LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_stream.c
// Function: gt_node_stream_create
GtNodeStream* gt_node_stream_create(const GtNodeStreamClass *nsc,
                                    bool ensure_sorting)
{
  GtNodeStream *ns;
  gt_assert(nsc && nsc->size);
  ns = gt_calloc(1, nsc->size);
  ns->c_class = nsc;
  ns->members = gt_calloc(1, sizeof (GtNodeStreamMembers));
  ns->members->ensure_sorting = ensure_sorting;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4994f
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x4994f
leaq 0x9f534(%rip), %r15     # 0xe8e3d
movl $0x1, %edi
movq %r15, %rdx
movl $0x38, %ecx
callq 0x3601f
movq %rax, %r12
movq %r14, (%rax)
movl $0x1, %edi
movl $0x10, %esi
movq %r15, %rdx
movl $0x3a, %ecx
callq 0x3601f
movq %rax, 0x8(%r12)
movb %bl, 0x8(%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13b36
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_stream.c
// Function: gt_node_stream_delete
void gt_node_stream_delete(GtNodeStream *ns)
{
  if (!ns) return;
  if (ns->members->reference_count) {
    ns->members->reference_count--;
    return;
  }
  gt_assert(ns->c_class);
  if (ns->c_class->free) ns->c_class->free(ns);
  gt_genome_node_delete(ns->members->buffer);
  gt_free(ns->members);
  gt_free(ns);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x49986
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0xc(%rax), %ecx
testl %ecx, %ecx
je 0x4998e
decl %ecx
movl %ecx, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x499df
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x499a4
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0x42ade
movq 0x8(%rbx), %rdi
leaq 0x9f482(%rip), %r14     # 0xe8e3d
movq %r14, %rsi
movl $0x50, %edx
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x51, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
callq 0x13ba4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_stream.c
// Function: gt_node_stream_next
int gt_node_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err)
{
  GtGenomeNode *new_node = NULL;
  int had_err = 0;
  gt_assert(ns && ns->c_class && ns->c_class->next);
  gt_error_check(err);
  /* filling */
  if (!ns->members->buffer)
    had_err = ns->c_class->next(ns, &ns->members->buffer, err);
  if (!had_err && ns->members->buffer)
    had_err = ns->c_class->next(ns, &new_node, err);
#ifndef NDEBUG
  /* checking */
  if (!had_err && ns->members->ensure_sorting && ns->members->buffer &&
      new_node) {
    gt_assert(gt_genome_node_compare(&ns->members->buffer, &new_node) <= 0);
  }
#endif
  /* serving */
  if (!had_err) {
    *gn = ns->members->buffer;
    ns->members->buffer = new_node;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x49ab7
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x49ab7
cmpq $0x0, 0x10(%rax)
je 0x49ab7
movq %rdx, %r15
movq %rsi, %r14
testq %rdx, %rdx
je 0x49a31
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0x49abc
movq 0x8(%rbx), %rsi
xorl %ebp, %ebp
cmpq $0x0, (%rsi)
jne 0x49a4b
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rdx
callq *0x10(%rax)
movl %eax, %ebp
testl %ebp, %ebp
jne 0x49a6e
movq 0x8(%rbx), %rax
cmpq $0x0, (%rax)
je 0x49a6c
movq (%rbx), %rax
movq %rsp, %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0x10(%rax)
movl %eax, %ebp
jmp 0x49a6e
xorl %ebp, %ebp
testl %ebp, %ebp
jne 0x49aaa
movq 0x8(%rbx), %rdi
cmpb $0x1, 0x8(%rdi)
jne 0x49a95
cmpq $0x0, (%rdi)
je 0x49a95
cmpq $0x0, (%rsp)
je 0x49a95
movq %rsp, %rsi
callq 0x4208a
testl %eax, %eax
jg 0x49ac1
movq 0x8(%rbx), %rax
movq (%rax), %rax
movq %rax, (%r14)
movq (%rsp), %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x13c49
callq 0x13bdb
callq 0x13c12
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_stream.c
// Function: gt_node_stream_pull
int gt_node_stream_pull(GtNodeStream *ns, GtError *err)
{
  GtGenomeNode *gn;
  int had_err;
  gt_assert(ns);
  gt_error_check(err);
  while (!(had_err = gt_node_stream_next(ns, &gn, err)) && gn)
    gt_genome_node_delete(gn);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x49b43
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x49aeb
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x49b48
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x499e4
testl %eax, %eax
sete %cl
movq (%r15), %rdi
testq %rdi, %rdi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x49b39
leaq 0x8(%rsp), %r15
callq 0x42ade
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x499e4
testl %eax, %eax
jne 0x49b39
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x49b18
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13cb7
callq 0x13c80
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_visitor.c
// Function: gt_node_visitor_class_new
GtNodeVisitorClass*
gt_node_visitor_class_new(size_t size,
                          GtNodeVisitorFreeFunc free,
                          GtNodeVisitorCommentNodeFunc comment_node,
                          GtNodeVisitorFeatureNodeFunc feature_node,
                          GtNodeVisitorRegionNodeFunc region_node,
                          GtNodeVisitorSequenceNodeFunc sequence_node,
                          GtNodeVisitorEOFNodeFunc eof_node)
{
  GtNodeVisitorClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->comment_node = comment_node;
  c_class->feature_node = feature_node;
  c_class->region_node = region_node;
  c_class->sequence_node = sequence_node;
  c_class->eof_node = eof_node;
  return c_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x49bd7
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x40, %edi
callq 0x71ca4
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x13d5e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_visitor.c
// Function: gt_node_visitor_create
GtNodeVisitor* gt_node_visitor_create(const GtNodeVisitorClass *nvc)
{
  GtNodeVisitor *nv;
  gt_assert(nvc && nvc->size);
  nv = gt_calloc(1, nvc->size);
  nv->c_class = nvc;
  return nv;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x49c18
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x49c18
leaq 0x9f3a3(%rip), %rdx     # 0xe8fa7
movl $0x1, %edi
movl $0x47, %ecx
callq 0x3601f
movq %rbx, (%rax)
popq %rbx
retq
callq 0x13dcc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_visitor.c
// Function: gt_node_visitor_visit_comment_node
int gt_node_visitor_visit_comment_node(GtNodeVisitor *nv, GtCommentNode *cn,
                                       GtError *err)
{
  gt_error_check(err);
  gt_assert(nv && cn && nv->c_class);
  if (nv->c_class->comment_node)
    return nv->c_class->comment_node(nv, cn, err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x49c55
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x49c8d
testq %r15, %r15
je 0x49c88
testq %r14, %r14
je 0x49c88
movq (%r15), %rax
testq %rax, %rax
je 0x49c88
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x49c80
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x13e71
callq 0x13e3a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_visitor.c
// Function: gt_node_visitor_visit_feature_node
int gt_node_visitor_visit_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                                       GtError *err)
{
  gt_error_check(err);
  gt_assert(nv && fn && nv->c_class);
  if (nv->c_class->feature_node)
    return nv->c_class->feature_node(nv, fn, err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x49cb1
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x49ce9
testq %r15, %r15
je 0x49ce4
testq %r14, %r14
je 0x49ce4
movq (%r15), %rax
testq %rax, %rax
je 0x49ce4
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x49cdc
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x13edf
callq 0x13ea8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_visitor.c
// Function: gt_node_visitor_visit_meta_node
int gt_node_visitor_visit_meta_node(GtNodeVisitor *nv, GtMetaNode *mn,
                                    GtError *err)
{
  gt_error_check(err);
  gt_assert(nv && mn && nv->c_class);
  if (nv->c_class->meta_node)
    return nv->c_class->meta_node(nv, mn, err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x49d0d
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x49d45
testq %r15, %r15
je 0x49d40
testq %r14, %r14
je 0x49d40
movq (%r15), %rax
testq %rax, %rax
je 0x49d40
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x49d38
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x13f4d
callq 0x13f16
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_visitor.c
// Function: gt_node_visitor_visit_region_node
int gt_node_visitor_visit_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                      GtError *err)
{
  gt_error_check(err);
  gt_assert(nv && rn && nv->c_class);
  if (nv->c_class->region_node)
    return nv->c_class->region_node(nv, rn, err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x49d69
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x49da1
testq %r15, %r15
je 0x49d9c
testq %r14, %r14
je 0x49d9c
movq (%r15), %rax
testq %rax, %rax
je 0x49d9c
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x49d94
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x13fbb
callq 0x13f84
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_visitor.c
// Function: gt_node_visitor_visit_sequence_node
int gt_node_visitor_visit_sequence_node(GtNodeVisitor *nv, GtSequenceNode *sn,
                                        GtError *err)
{
  gt_error_check(err);
  gt_assert(nv && sn && nv->c_class);
  if (nv->c_class->sequence_node)
    return nv->c_class->sequence_node(nv, sn, err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x49dc5
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x49dfd
testq %r15, %r15
je 0x49df8
testq %r14, %r14
je 0x49df8
movq (%r15), %rax
testq %rax, %rax
je 0x49df8
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x49df0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x14029
callq 0x13ff2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_visitor.c
// Function: gt_node_visitor_visit_eof_node
int gt_node_visitor_visit_eof_node(GtNodeVisitor *nv, GtEOFNode *eofn,
                                   GtError *err)
{
  gt_error_check(err);
  gt_assert(nv && eofn && nv->c_class);
  if (nv->c_class->eof_node)
    return nv->c_class->eof_node(nv, eofn, err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x49e21
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x49e59
testq %r15, %r15
je 0x49e54
testq %r14, %r14
je 0x49e54
movq (%r15), %rax
testq %rax, %rax
je 0x49e54
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x49e4c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmpq *%rax
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x14099
callq 0x14060
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_visitor.c
// Function: gt_node_visitor_delete
void gt_node_visitor_delete(GtNodeVisitor *nv)
{
  if (!nv) return;
  gt_assert(nv->c_class);
  if (nv->c_class->free)
    nv->c_class->free(nv);
  gt_free(nv);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x49e92
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x49e94
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x49e7d
movq %rbx, %rdi
callq *%rax
leaq 0x9f123(%rip), %rsi     # 0xe8fa7
movq %rbx, %rdi
movl $0x95, %edx
popq %rbx
jmp 0x362a0
popq %rbx
retq
callq 0x140d2
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orphanage.c
// Function: gt_orphanage_new
GtOrphanage* gt_orphanage_new(void)
{
  GtOrphanage *o = gt_malloc(sizeof *o);
  o->orphans = gt_queue_new();
  o->missing_parents = gt_cstr_table_new();
  o->orphan_ids = gt_cstr_table_new();
  return o;
}

// Assembly:
pushq %rbx
leaq 0x9f319(%rip), %rsi     # 0xe91bd
movl $0x18, %edi
movl $0x23, %edx
callq 0x35ee2
movq %rax, %rbx
callq 0x7c028
movq %rax, (%rbx)
callq 0x72918
movq %rax, 0x8(%rbx)
callq 0x72918
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orphanage.c
// Function: gt_orphanage_delete
void gt_orphanage_delete(GtOrphanage *o)
{
  if (!o) return;
  gt_cstr_table_delete(o->orphan_ids);
  gt_cstr_table_delete(o->missing_parents);
  while (gt_queue_size(o->orphans))
    gt_genome_node_delete(gt_queue_get(o->orphans));
  gt_queue_delete(o->orphans);
  gt_free(o);
}

// Assembly:
testq %rdi, %rdi
je 0x49f2c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x72c9c
movq 0x8(%rbx), %rdi
callq 0x72c9c
movq (%rbx), %rdi
callq 0x7c194
testq %rax, %rax
je 0x49f0f
movq (%rbx), %rdi
callq 0x7c132
movq %rax, %rdi
callq 0x42ade
jmp 0x49ef0
movq (%rbx), %rdi
callq 0x7c623
leaq 0x9f29f(%rip), %rsi     # 0xe91bd
movq %rbx, %rdi
movl $0x32, %edx
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orphanage.c
// Function: gt_orphanage_reset
void gt_orphanage_reset(GtOrphanage *o)
{
  gt_assert(o);
  while (gt_queue_size(o->orphans))
    gt_genome_node_delete(gt_queue_get(o->orphans));
  gt_cstr_table_reset(o->missing_parents);
  gt_cstr_table_reset(o->orphan_ids);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x49f68
movq %rdi, %rbx
movq (%rbx), %rdi
callq 0x7c194
testq %rax, %rax
je 0x49f55
movq (%rbx), %rdi
callq 0x7c132
movq %rax, %rdi
callq 0x42ade
jmp 0x49f36
movq 0x8(%rbx), %rdi
callq 0x72ab8
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x72ab8
callq 0x1410b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orphanage.c
// Function: gt_orphanage_add
void gt_orphanage_add(GtOrphanage *o, GtGenomeNode *orphan,
                      const char *orphan_id, GtStrArray *missing_parents)
{
  const char *missing_parent;
  GtUword i;
  gt_assert(o && orphan);
  gt_assert(gt_feature_node_get_attribute((GtFeatureNode*) orphan,
                                          GT_GFF_PARENT));
  gt_queue_add(o->orphans, orphan);
  if (orphan_id && !gt_cstr_table_get(o->orphan_ids, orphan_id))
    gt_cstr_table_add(o->orphan_ids, orphan_id);
  if (missing_parents) {
    for (i = 0; i < gt_str_array_size(missing_parents); i++) {
      missing_parent = gt_str_array_get(missing_parents, i);
      if (!gt_cstr_table_get(o->missing_parents, missing_parent))
        gt_cstr_table_add(o->missing_parents, missing_parent);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4a034
movq %rsi, %r12
testq %rsi, %rsi
je 0x4a034
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
leaq 0x9d7de(%rip), %rsi     # 0xe7778
movq %r12, %rdi
callq 0x3f850
testq %rax, %rax
je 0x4a039
movq (%r14), %rdi
movq %r12, %rsi
callq 0x7c043
testq %r15, %r15
je 0x49fd8
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x729dd
testq %rax, %rax
jne 0x49fd8
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x7297e
testq %rbx, %rbx
je 0x4a028
movq %rbx, %rdi
callq 0x3d560
testq %rax, %rax
je 0x4a028
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d3e2
movq %rax, %r12
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0x729dd
testq %rax, %rax
jne 0x4a018
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x7297e
incq %r15
movq %rbx, %rdi
callq 0x3d560
cmpq %rax, %r15
jb 0x49fed
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x14142
callq 0x14179
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/orphanage.c
// Function: gt_orphanage_get_orphan
GtGenomeNode* gt_orphanage_get_orphan(GtOrphanage *o)
{
  gt_assert(o);
  if (gt_queue_size(o->orphans))
    return gt_queue_get(o->orphans);
  return NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x4a07a
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x7c194
testq %rax, %rax
je 0x4a076
movq (%rbx), %rdi
popq %rbx
jmp 0x7c132
xorl %eax, %eax
popq %rbx
retq
callq 0x141e7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/region_node.c
// Function: gt_region_node_class
const GtGenomeNodeClass* gt_region_node_class()
{
  static const GtGenomeNodeClass *gnc = NULL;
  gt_class_alloc_lock_enter();
  if (!gnc) {
    gnc = gt_genome_node_class_new(sizeof (GtRegionNode),
                                   region_node_free,
                                   region_node_get_seqid,
                                   region_node_get_seqid,
                                   region_node_get_range,
                                   region_node_set_range,
                                   region_node_change_seqid,
                                   region_node_accept);
  }
  gt_class_alloc_lock_leave();
  return gnc;
}

// Assembly:
pushq %rax
callq 0x71d9b
cmpq $0x0, 0x108a96(%rip)    # 0x152b68
jne 0x4a119
leaq 0x126(%rip), %rax       # 0x4a201
leaq 0xd6(%rip), %r10        # 0x4a1b8
leaq 0x3e(%rip), %rsi        # 0x4a127
leaq 0x64(%rip), %rcx        # 0x4a154
leaq 0x77(%rip), %r8         # 0x4a16e
leaq 0x91(%rip), %r9         # 0x4a18f
movl $0x48, %edi
movq %rcx, %rdx
pushq %rax
pushq %r10
callq 0x41cc8
addq $0x10, %rsp
movq %rax, 0x108a4f(%rip)    # 0x152b68
callq 0x71db1
movq 0x108a43(%rip), %rax    # 0x152b68
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/region_node.c
// Function: region_node_change_seqid
static void region_node_change_seqid(GtGenomeNode *gn, GtStr *seqid)
{
  GtRegionNode *rn = gt_region_node_cast(gn);
  gt_assert(rn && seqid);
  gt_str_delete(rn->seqid);
  rn->seqid = gt_str_ref(seqid);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4a0c4
movq %rax, %rdi
movq %r14, %rsi
callq 0x41edd
testq %rbx, %rbx
je 0x4a1fc
movq %rax, %r14
testq %rax, %rax
je 0x4a1fc
movq 0x30(%r14), %rdi
callq 0x3d1eb
movq %rbx, %rdi
callq 0x3c561
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x142c3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/region_node.c
// Function: region_node_accept
static int region_node_accept(GtGenomeNode *gn, GtNodeVisitor *nv, GtError *err)
{
  GtRegionNode *rn;
  gt_error_check(err);
  rn = gt_region_node_cast(gn);
  return gt_node_visitor_visit_region_node(nv, rn, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x4a220
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x4a243
callq 0x4a0c4
movq %rax, %rdi
movq %r15, %rsi
callq 0x41edd
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x49d4a
callq 0x142fa
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/region_node.c
// Function: gt_region_node_new
GtGenomeNode* gt_region_node_new(GtStr *seqid, GtUword start,
                                               GtUword end)
{
  GtGenomeNode *gn = gt_genome_node_create(gt_region_node_class());
  GtRegionNode *rn = gt_region_node_cast(gn);
  gt_assert(seqid);
  gt_assert(start <= end);
  rn->seqid = gt_str_ref(seqid);
  rn->range.start = start;
  rn->range.end   = end;
  return gn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x4a0c4
movq %rax, %rdi
callq 0x41e44
movq %rax, %r12
callq 0x4a0c4
movq %rax, %rdi
movq %r12, %rsi
callq 0x41edd
testq %r15, %r15
je 0x4a2a8
cmpq %rbx, %r14
ja 0x4a2ad
movq %rax, %r13
movq %r15, %rdi
callq 0x3c561
movq %rax, 0x30(%r13)
movq %r14, 0x38(%r13)
movq %rbx, 0x40(%r13)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x14368
callq 0x14331
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/region_node.c
// Function: gt_region_node_consolidate
void gt_region_node_consolidate(GtRegionNode *rn_a, GtRegionNode *rn_b)
{
  GtRange range_a, range_b;
  gt_assert(rn_a);
  gt_assert(rn_b);
  gt_assert(!gt_str_cmp(gt_genome_node_get_seqid((GtGenomeNode*) rn_a),
                        gt_genome_node_get_seqid((GtGenomeNode*) rn_b)));
  range_a = gt_genome_node_get_range((GtGenomeNode*) rn_a);
  range_b = gt_genome_node_get_range((GtGenomeNode*) rn_b);
  range_a = gt_range_join(&range_a, &range_b);
  gt_genome_node_set_range((GtGenomeNode*) rn_a, &range_a);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x4a349
movq %rsi, %r14
testq %rsi, %rsi
je 0x4a34e
movq %rdi, %rbx
callq 0x41f3f
movq %rax, %r15
movq %r14, %rdi
callq 0x41f3f
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c4b0
testl %eax, %eax
jne 0x4a353
movq %rbx, %rdi
callq 0x41f83
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %r14, %rdi
callq 0x41f83
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r15, %rdi
callq 0x7e16b
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41fe4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1440d
callq 0x143d6
callq 0x1439f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node.c
// Function: gt_sequence_node_class
const GtGenomeNodeClass* gt_sequence_node_class()
{
  static const GtGenomeNodeClass *gnc = NULL;
  gt_class_alloc_lock_enter();
  if (!gnc) {
    gnc = gt_genome_node_class_new(sizeof (GtSequenceNode),
                                   sequence_node_free,
                                   sequence_node_get_seqid,
                                   sequence_node_get_seqid,
                                   sequence_node_get_range,
                                   NULL,
                                   sequence_node_change_seqid,
                                   sequence_node_accept);
  }
  gt_class_alloc_lock_leave();
  return gnc;
}

// Assembly:
pushq %rax
callq 0x71d9b
cmpq $0x0, 0x1087f2(%rip)    # 0x152b70
jne 0x4a3c1
leaq 0xda(%rip), %rax        # 0x4a461
leaq 0x8a(%rip), %r10        # 0x4a418
leaq 0x3a(%rip), %rsi        # 0x4a3cf
leaq 0x5d(%rip), %rcx        # 0x4a3f9
leaq 0x70(%rip), %r8         # 0x4a413
movl $0x40, %edi
movq %rcx, %rdx
xorl %r9d, %r9d
pushq %rax
pushq %r10
callq 0x41cc8
addq $0x10, %rsp
movq %rax, 0x1087af(%rip)    # 0x152b70
callq 0x71db1
movq 0x1087a3(%rip), %rax    # 0x152b70
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node.c
// Function: sequence_node_change_seqid
static void sequence_node_change_seqid(GtGenomeNode *gn, GtStr *seqid)
{
  GtSequenceNode *sn = gt_sequence_node_cast(gn);
  gt_assert(sn && seqid);
  gt_str_delete(sn->description);
  sn->description = gt_str_ref(seqid);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4a370
movq %rax, %rdi
movq %r14, %rsi
callq 0x41edd
testq %rbx, %rbx
je 0x4a45c
movq %rax, %r14
testq %rax, %rax
je 0x4a45c
movq 0x30(%r14), %rdi
callq 0x3d1eb
movq %rbx, %rdi
callq 0x3c561
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x14444
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node.c
// Function: sequence_node_accept
static int sequence_node_accept(GtGenomeNode *gn, GtNodeVisitor *nv,
                                GtError *err)
{
  GtSequenceNode *sn;
  gt_error_check(err);
  sn = gt_sequence_node_cast(gn);
  return gt_node_visitor_visit_sequence_node(nv, sn, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x4a480
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x4a4a3
callq 0x4a370
movq %rax, %rdi
movq %r15, %rsi
callq 0x41edd
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x49da6
callq 0x1447b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node.c
// Function: gt_sequence_node_new
GtGenomeNode* gt_sequence_node_new(const char *description, GtStr *sequence)
{
  GtGenomeNode *gn = gt_genome_node_create(gt_sequence_node_class());
  GtSequenceNode *sn = gt_sequence_node_cast(gn);
  gt_assert(description && sequence);
  sn->description = gt_str_new_cstr(description);
  sn->sequence = gt_str_ref(sequence);
  return gn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x4a370
movq %rax, %rdi
callq 0x41e44
movq %rax, %r14
callq 0x4a370
movq %rax, %rdi
movq %r14, %rsi
callq 0x41edd
testq %r15, %r15
je 0x4a50c
testq %rbx, %rbx
je 0x4a50c
movq %rax, %r12
movq %r15, %rdi
callq 0x3c03d
movq %rax, 0x30(%r12)
movq %rbx, %rdi
callq 0x3c561
movq %rax, 0x38(%r12)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x144b2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_new
GtTagValueMap gt_tag_value_map_new(const char *tag, const char *value)
{
  GtTagValueMap map;
  size_t tag_len, value_len;
  gt_assert(tag && value);
  tag_len = strlen(tag);
  value_len = strlen(value);
  gt_assert(tag_len && value_len);
  map = gt_malloc((tag_len + 1 + value_len + 1 + 1) * sizeof *map);
  memcpy(map, tag, tag_len + 1);
  memcpy(map + tag_len + 1, value, value_len + 1);
  map[tag_len + 1 + value_len + 1] = '\0';
  return map;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4a622
movq %rsi, %rbx
testq %rsi, %rsi
je 0x4a622
movq %rdi, %r14
callq 0xb260
movq %rax, %r12
movq %rbx, %rdi
callq 0xb260
testq %r12, %r12
je 0x4a627
movq %rax, %r15
testq %rax, %rax
je 0x4a627
leaq 0x1(%r12), %r13
leaq (%r12,%r15), %rax
incq %rax
movq %rax, (%rsp)
leaq (%r12,%r15), %rdi
addq $0x3, %rdi
leaq 0x9ef09(%rip), %rsi     # 0xe94e0
movl $0x28, %edx
callq 0x35ee2
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0xb520
leaq (%r12,%rbp), %rdi
incq %rdi
incq %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0xb520
movq (%rsp), %rax
movb $0x0, 0x1(%rbp,%rax)
movq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1458e
callq 0x145c5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_add
void gt_tag_value_map_add(GtTagValueMap *map, const char *tag,
                          const char *value)
{
  size_t tag_len, value_len, map_len = 0;
  GT_UNUSED const char *tag_already_used;
  gt_assert(map && *map && tag && value);
  tag_len = strlen(tag);
  value_len = strlen(value);
  gt_assert(tag_len && value_len);
  /* determine current map length */
  tag_already_used = get_value(*map, tag, &map_len);
  gt_assert(!tag_already_used); /* map does not contain given <tag> already */
  /* allocate additional space */
  *map = gt_realloc(*map, map_len + tag_len + 1 + value_len + 1 + 1);
  /* store new tag/value pair */
  memcpy(*map + map_len, tag, tag_len + 1);
  memcpy(*map + map_len + tag_len + 1, value, value_len + 1);
  (*map)[map_len + tag_len + 1 + value_len + 1] = '\0';
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rsp)
testq %rdi, %rdi
je 0x4a724
movq %rdx, %r14
testq %rdx, %rdx
je 0x4a724
movq %rsi, %r15
testq %rsi, %rsi
je 0x4a724
movq %rdi, %rbx
movq (%rdi), %rbp
testq %rbp, %rbp
je 0x4a724
movq %r15, %rdi
callq 0xb260
movq %rax, %r12
movq %r14, %rdi
callq 0xb260
testq %r12, %r12
je 0x4a729
movq %rax, %r13
testq %rax, %rax
je 0x4a729
movq %rsp, %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x4a733
testq %rax, %rax
jne 0x4a72e
movq (%rbx), %rdi
movq (%rsp), %rax
leaq (%r12,%r13), %rcx
leaq (%rax,%rcx), %rsi
addq $0x3, %rsi
leaq 0x9ee18(%rip), %rdx     # 0xe94e0
movl $0x83, %ecx
callq 0x36116
movq %rax, (%rbx)
addq (%rsp), %rax
leaq 0x1(%r12), %rdx
movq %rax, %rdi
movq %r15, %rsi
callq 0xb520
movq (%rbx), %rax
addq (%rsp), %rax
leaq (%r12,%rax), %rdi
incq %rdi
movq %r13, %rdx
incq %rdx
movq %r14, %rsi
callq 0xb520
movq (%rbx), %rax
addq (%rsp), %rax
addq %r12, %rax
movb $0x0, 0x2(%r13,%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1466c
callq 0x145fc
callq 0x14633
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tag_value_map.c
// Function: get_value
static char* get_value(const GtTagValueMap map, const char *tag,
                       size_t *map_len)
{
  char *map_ptr;
  const char *tag_ptr;
  /* search for equal tag */
  map_ptr = map;
  tag_ptr = tag;
  for (;;) {
    while (*map_ptr == *tag_ptr++) {
      if (*map_ptr == '\0') {
        if (*(map_ptr+1) != '\0')
          return (map_ptr+1); /* match found -> return value */
        else
          break;
      } else map_ptr++;
    }
    /* tag did not match */
    while (*map_ptr++ != '\0'); /* go to value */
    if (*map_ptr == '\0')
      break; /* no next pair found */
    else {
      while (*map_ptr != '\0') /* skip value */
        map_ptr++;
      if (*(map_ptr+1) != '\0')
        map_ptr++;
    }
    /* reset tag pointer */
    tag_ptr = tag;
  }
  if (map_len)
    *map_len = map_ptr - map; /* save map length */
  return NULL;
}

// Assembly:
movq %rdi, %rax
movb (%rsi), %cl
incq %rsi
negq %rdi
movb (%rax), %r8b
cmpb %cl, %r8b
jne 0x4a76d
incq %rax
movq %rsi, %r9
testb %r8b, %r8b
je 0x4a765
movb (%rax), %r8b
leaq 0x1(%r9), %r10
incq %rax
cmpb (%r9), %r8b
movq %r10, %r9
je 0x4a74c
jmp 0x4a76a
cmpb $0x0, (%rax)
jne 0x4a7a2
decq %rax
leaq (%rdi,%rax), %r8
incq %r8
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x4a771
cmpb $0x0, (%rax)
je 0x4a798
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x4a782
leaq -0x1(%rax), %r8
cmpb $0x0, (%rax)
cmoveq %r8, %rax
jmp 0x4a73e
testq %rdx, %rdx
je 0x4a7a0
movq %r8, (%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_remove
void gt_tag_value_map_remove(GtTagValueMap *map, const char *tag)
{
  size_t tag_len, value_len, map_len;
  char *value;
  gt_assert(map && tag && get_map_nof_items(*map) > 1);
  tag_len = strlen(tag);
  gt_assert(tag_len);
  /* determine value for given tag */
  value = get_value(*map, tag, NULL);
  gt_assert(value);
  map_len = get_map_len(*map);
  value_len = strlen(value);
  /* move memory from end position of value to start position of tag */
  memmove(value - tag_len - 1, value + value_len + 1,
          map_len - ((size_t) value - (size_t) *map + value_len));
  *map = gt_realloc(*map, map_len - (tag_len + 1 + value_len + 1) + 1);
  gt_assert((*map)[map_len - (tag_len + 1 + value_len + 1)] == '\0');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4a8b9
movq %rsi, %r14
testq %rsi, %rsi
je 0x4a8b9
movq %rdi, %r13
movq (%rdi), %r12
xorl %eax, %eax
movq %r12, %rdx
xorl %ecx, %ecx
cmpb $0x0, (%rdx)
leaq 0x1(%rdx), %rdx
jne 0x4a7d0
movl %ecx, %esi
andb $0x1, %sil
movzbl %sil, %esi
addq %rsi, %rax
cmpb $0x0, (%rdx)
je 0x4a7f0
xorb $0x1, %cl
jmp 0x4a7d0
cmpq $0x1, %rax
jbe 0x4a8b9
movq %r14, %rdi
callq 0xb260
testq %rax, %rax
je 0x4a8be
movq %rax, %rbx
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4a733
testq %rax, %rax
je 0x4a8c3
movq %rax, %r14
movq %rbx, %r15
negq %r15
movq %r13, (%rsp)
movq (%r13), %r13
movq %r13, %rbp
movq %rbp, %rax
incq %rbp
cmpb $0x0, (%rax)
jne 0x4a838
leaq 0x2(%rax), %rbp
cmpb $0x0, 0x1(%rax)
jne 0x4a838
notq %r13
addq %rbp, %r13
movq %r14, %rdi
callq 0xb260
movq %rax, %r12
leaq (%r14,%r15), %rdi
decq %rdi
leaq (%r14,%rax), %rsi
incq %rsi
addq %rax, %r14
notq %r14
addq %rbp, %r14
movq %r14, %rdx
callq 0xba60
movq (%rsp), %r14
movq (%r14), %rdi
addq %r12, %rbx
subq %rbx, %r13
leaq -0x1(%r13), %rsi
leaq 0x9ec4b(%rip), %rdx     # 0xe94e0
movl $0x99, %ecx
callq 0x36116
movq %rax, (%r14)
cmpb $0x0, -0x2(%rax,%r13)
jne 0x4a8c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x146a3
callq 0x1474e
callq 0x14715
callq 0x146dc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_foreach
void gt_tag_value_map_foreach(const GtTagValueMap map,
                              GtTagValueMapIteratorFunc func,
                              void *data)
{
  const char *map_ptr, *tag;
  gt_assert(map && func);
  map_ptr = map;
  do { /* the map has at least one tag/value pair */
    tag = map_ptr;
    while (*map_ptr++ != '\0'); /* skip tag and \0 */
    func(tag, map_ptr /* value */, data);
    while (*map_ptr++ != '\0'); /* skip value and \0 */
  } while (*map_ptr != '\0');
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4ab43
movq %rsi, %r14
testq %rsi, %rsi
je 0x4ab43
movq %rdx, %rbx
movq %rdi, %r15
cmpb $0x0, (%r15)
leaq 0x1(%r15), %r15
jne 0x4ab19
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
movq %r15, %rdi
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x4ab2f
cmpb $0x0, (%rdi)
jne 0x4ab16
popq %rbx
popq %r14
popq %r15
retq
callq 0x14916
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_show
void gt_tag_value_map_show(const GtTagValueMap map)
{
  bool null_terminator_read = false;
  const char *map_ptr;
  gt_assert(map);
  map_ptr = map;
  for (;;) {
    if (*map_ptr == '\0') {
      printf("\\0");
      if (null_terminator_read)
        break;
      else
        null_terminator_read = true;
    }
    else {
      gt_xputchar(*map_ptr);
      null_terminator_read = false;
    }
    map_ptr++;
  }
  gt_xputchar('\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4ab9e
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x9eb72(%rip), %r14     # 0xe96d2
movsbl (%rbx), %edi
testl %edi, %edi
sete %r15b
je 0x4ab72
callq 0x3dd24
jmp 0x4ab82
movq %r14, %rdi
xorl %eax, %eax
callq 0xb070
testb $0x1, %bpl
jne 0x4ab8a
incq %rbx
movl %r15d, %ebp
jmp 0x4ab60
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3dd24
callq 0x1494f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tag_value_map.c
// Function: gt_tag_value_map_example
int gt_tag_value_map_example(GT_UNUSED GtError *err)
{
  GtTagValueMap map;

  gt_error_check(err);

  map = gt_tag_value_map_new("tag 1", "value 1");
  gt_tag_value_map_add(&map, "tag 2", "value 2");
  gt_tag_value_map_add(&map, "tag 3", "value 3");

  gt_assert(!gt_tag_value_map_get(map, "unused tag"));
  gt_assert(!strcmp(gt_tag_value_map_get(map, "tag 1"), "value 1"));
  gt_assert(!strcmp(gt_tag_value_map_get(map, "tag 2"), "value 2"));
  gt_assert(!strcmp(gt_tag_value_map_get(map, "tag 3"), "value 3"));

  gt_tag_value_map_delete(map);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4abba
callq 0x3566a
testb %al, %al
jne 0x4acbc
leaq 0x9eb2d(%rip), %rdi     # 0xe96ee
leaq 0x9eb2c(%rip), %rsi     # 0xe96f4
callq 0x4a578
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x9eb20(%rip), %rsi     # 0xe96fc
leaq 0x9eb1f(%rip), %rdx     # 0xe9702
movq %rbx, %rdi
callq 0x4a62c
leaq 0x9eb18(%rip), %rsi     # 0xe970a
leaq 0x9eb17(%rip), %rdx     # 0xe9710
movq %rbx, %rdi
callq 0x4a62c
movq (%rbx), %rdi
leaq 0x9eb0d(%rip), %rsi     # 0xe9718
callq 0x4aab6
testq %rax, %rax
jne 0x4aca8
movq 0x8(%rsp), %rdi
leaq 0x9eac9(%rip), %rsi     # 0xe96ee
callq 0x4aab6
leaq 0x9eac3(%rip), %rsi     # 0xe96f4
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4acad
movq 0x8(%rsp), %rdi
leaq 0x9eab3(%rip), %rsi     # 0xe96fc
callq 0x4aab6
leaq 0x9eaad(%rip), %rsi     # 0xe9702
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4acb2
movq 0x8(%rsp), %rdi
leaq 0x9ea9d(%rip), %rsi     # 0xe970a
callq 0x4aab6
leaq 0x9ea97(%rip), %rsi     # 0xe9710
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4acb7
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4aca0
leaq 0x9e84a(%rip), %rsi     # 0xe94e0
movl $0x199, %edx            # imm = 0x199
callq 0x362a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x149c1
callq 0x149fa
callq 0x14a33
callq 0x14a6c
callq 0x14988
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tag_value_map.c
// Function: create_filled_tag_value_list
static GtTagValueMap create_filled_tag_value_list(void)
{
  GtTagValueMap map = gt_tag_value_map_new("tag 1", "value 1");
  gt_tag_value_map_add(&map, "tag 2", "value 2");
  gt_tag_value_map_add(&map, "tag 3", "value 3");

  gt_assert(!gt_tag_value_map_get(map, "unused tag"));
  gt_assert(!gt_tag_value_map_get(map, "value 1"));
  gt_assert(!gt_tag_value_map_get(map, "value 2"));
  gt_assert(!gt_tag_value_map_get(map, "value 3"));
  gt_assert(!strcmp(gt_tag_value_map_get(map, "tag 1"), "value 1"));
  gt_assert(!strcmp(gt_tag_value_map_get(map, "tag 2"), "value 2"));
  gt_assert(!strcmp(gt_tag_value_map_get(map, "tag 3"), "value 3"));

  return map;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0x9dd06(%rip), %rdi     # 0xe96ee
leaq 0x9dd05(%rip), %rsi     # 0xe96f4
callq 0x4a578
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x9dcf9(%rip), %rsi     # 0xe96fc
leaq 0x9dcf8(%rip), %rdx     # 0xe9702
movq %rbx, %rdi
callq 0x4a62c
leaq 0x9dcf1(%rip), %rsi     # 0xe970a
leaq 0x9dcf0(%rip), %rdx     # 0xe9710
movq %rbx, %rdi
callq 0x4a62c
movq (%rbx), %rdi
leaq 0x9dce6(%rip), %rsi     # 0xe9718
callq 0x4aab6
testq %rax, %rax
jne 0x4bb05
movq 0x8(%rsp), %rdi
leaq 0x9dca8(%rip), %rsi     # 0xe96f4
callq 0x4aab6
testq %rax, %rax
jne 0x4bb0a
movq 0x8(%rsp), %rdi
leaq 0x9dc9c(%rip), %rsi     # 0xe9702
callq 0x4aab6
testq %rax, %rax
jne 0x4bb0f
movq 0x8(%rsp), %rdi
leaq 0x9dc90(%rip), %rsi     # 0xe9710
callq 0x4aab6
testq %rax, %rax
jne 0x4bb14
movq 0x8(%rsp), %rdi
leaq 0x9dc54(%rip), %rsi     # 0xe96ee
callq 0x4aab6
leaq 0x9dc4e(%rip), %rsi     # 0xe96f4
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4bb19
movq 0x8(%rsp), %rdi
leaq 0x9dc3e(%rip), %rsi     # 0xe96fc
callq 0x4aab6
leaq 0x9dc38(%rip), %rsi     # 0xe9702
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4bb1e
movq 0x8(%rsp), %rdi
leaq 0x9dc28(%rip), %rsi     # 0xe970a
callq 0x4aab6
leaq 0x9dc22(%rip), %rsi     # 0xe9710
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4bb23
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
callq 0x14d8a
callq 0x14dc3
callq 0x14dfc
callq 0x14e35
callq 0x14e6e
callq 0x14ea7
callq 0x14ee0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tidy_region_node_stream.c
// Function: gt_tidy_region_node_stream_class
const GtNodeStreamClass* gt_tidy_region_node_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtTidyRegionNodeStream),
                                   tidy_region_node_stream_free,
                                   tidy_region_node_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x71d9b
cmpq $0x0, 0x107042(%rip)    # 0x152b78
jne 0x4bb57
leaq 0x26(%rip), %rsi        # 0x4bb65
leaq 0x49(%rip), %rdx        # 0x4bb8f
movl $0x28, %edi
callq 0x498b0
movq %rax, 0x107021(%rip)    # 0x152b78
callq 0x71db1
movq 0x107015(%rip), %rax    # 0x152b78
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tidy_region_node_stream.c
// Function: tidy_region_node_stream_next
static int tidy_region_node_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                               GtError *err)
{
  GtTidyRegionNodeStream *ais;
  int had_err = 0;
  gt_error_check(err);
  ais = gt_tidy_region_node_stream_cast(ns);

  if (!ais->queued) {
    /* no nodes in the buffer -> get new nodes */
    while (!(had_err = gt_node_stream_next(ais->in_stream, gn, err)) && *gn) {
      gt_assert(*gn && !had_err);
      had_err = gt_genome_node_accept(*gn, ais->tidy_region_node_visitor, err);
      if (had_err) {
        /* we own the node -> delete it */
        gt_genome_node_delete(*gn);
        *gn = NULL;
        break;
      }
    }
    if (!had_err) {
      ais->queued = true;
    }
  }
  if (!had_err) {
    if (gt_tidy_region_node_visitor_node_buffer_size(
                                               ais->tidy_region_node_visitor)) {
      *gn = gt_tidy_region_node_visitor_get_node(ais->tidy_region_node_visitor);
    }
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x4bbb4
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0x4bc49
callq 0x4bb28
movq %rax, %rdi
movq %r14, %rsi
callq 0x49b60
movq %rax, %r14
xorl %ebp, %ebp
cmpb $0x0, 0x20(%rax)
jne 0x4bc1e
movq 0x10(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x499e4
testl %eax, %eax
jne 0x4bc0d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4bc11
movq 0x18(%r14), %rsi
movq %r15, %rdx
callq 0x42036
testl %eax, %eax
je 0x4bbcf
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x42ade
movq $0x0, (%rbx)
jmp 0x4bc13
movl %eax, %ebp
jmp 0x4bc13
xorl %ebp, %ebp
testl %ebp, %ebp
jne 0x4bc1e
movb $0x1, 0x20(%r14)
xorl %ebp, %ebp
testl %ebp, %ebp
jne 0x4bc3c
movq 0x18(%r14), %rdi
callq 0x4c0c8
testq %rax, %rax
je 0x4bc3c
movq 0x18(%r14), %rdi
callq 0x4c0e6
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x14f19
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tidy_region_node_stream.c
// Function: gt_tidy_region_node_stream_new
GtNodeStream* gt_tidy_region_node_stream_new(GtNodeStream *in_stream)
{
  GtTidyRegionNodeStream *tidy_region_node_stream;
  GtNodeStream *ns;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_tidy_region_node_stream_class(), false);
  tidy_region_node_stream = gt_tidy_region_node_stream_cast(ns);
  tidy_region_node_stream->in_stream = gt_node_stream_ref(in_stream);
  tidy_region_node_stream->tidy_region_node_visitor =
                                              gt_tidy_region_node_visitor_new();
  tidy_region_node_stream->queued = false;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4bca3
movq %rdi, %rbx
callq 0x4bb28
movq %rax, %rdi
xorl %esi, %esi
callq 0x498e8
movq %rax, %r14
callq 0x4bb28
movq %rax, %rdi
movq %r14, %rsi
callq 0x49b60
movq %rax, %r15
movq %rbx, %rdi
callq 0x49954
movq %rax, 0x10(%r15)
callq 0x4c071
movq %rax, 0x18(%r15)
movb $0x0, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x14f50
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: gt_tidy_region_node_visitor_class
const GtNodeVisitorClass* gt_tidy_region_node_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtTidyRegionNodeVisitor),
                                    tidy_region_node_visitor_free,
                                    tidy_region_node_visitor_comment_node,
                                    tidy_region_node_visitor_feature_node,
                                    tidy_region_node_visitor_region_node,
                                    tidy_region_node_visitor_sequence_node,
                                    tidy_region_node_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc,
                                            tidy_region_node_visitor_meta_node);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x71d9b
cmpq $0x0, 0x106eca(%rip)    # 0x152b80
jne 0x4bd06
leaq 0x326(%rip), %rax       # 0x4bfe5
movq %rax, (%rsp)
leaq 0x4a(%rip), %rsi        # 0x4bd14
leaq 0x6d(%rip), %rdx        # 0x4bd3e
leaq 0xac(%rip), %rcx        # 0x4bd84
leaq 0x203(%rip), %r8        # 0x4bee2
leaq 0x2b9(%rip), %r9        # 0x4bf9f
movl $0x20, %edi
callq 0x49b7c
movq %rax, 0x106e89(%rip)    # 0x152b80
leaq 0x32d(%rip), %rsi       # 0x4c02b
movq %rax, %rdi
callq 0x49bdc
callq 0x71db1
movq 0x106e6e(%rip), %rax    # 0x152b80
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: tidy_region_node_visitor_comment_node
static int tidy_region_node_visitor_comment_node(GtNodeVisitor *nv,
                                                 GtCommentNode *cn,
                                                 GT_UNUSED GtError *err)
{
  GtTidyRegionNodeVisitor *trnv;
  gt_error_check(err);
  trnv = tidy_region_node_visitor_cast(nv);
  gt_queue_add(trnv->node_buffer, cn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x4bd59
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x4bd7f
callq 0x4bca8
movq %rax, %rdi
movq %r14, %rsi
callq 0x49c1d
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x7c043
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x14f87
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/tidy_region_node_visitor.c
// Function: tidy_region_node_visitor_region_node
static int tidy_region_node_visitor_region_node(GtNodeVisitor *nv,
                                                GtRegionNode *rn,
                                                GT_UNUSED GtError *err)
{
  GtTidyRegionNodeVisitor *trnv;
  const char *seqid;
  gt_error_check(err);
  trnv = tidy_region_node_visitor_cast(nv);
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn));
  gt_assert(seqid);
  if (!gt_hashmap_get(trnv->region_nodes, seqid)) {
    gt_hashmap_add(trnv->region_nodes, gt_cstr_dup(seqid),
                   gt_genome_node_ref((GtGenomeNode*) rn));
    gt_assert(gt_hashmap_get(trnv->region_nodes, seqid));
  }
  gt_queue_add(trnv->node_buffer, rn);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x4bf06
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x4bf95
callq 0x4bca8
movq %rax, %rdi
movq %r14, %rsi
callq 0x49c1d
movq %rax, %r14
movq %rbx, %rdi
callq 0x41f3f
movq %rax, %rdi
callq 0x3c40b
testq %rax, %rax
je 0x4bf90
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0x77109
testq %rax, %rax
jne 0x4bf78
movq 0x18(%r14), %r12
movq %r15, %rdi
callq 0x722dc
movq %rax, %r13
movq %rbx, %rdi
callq 0x41ca0
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x77144
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x77109
testq %rax, %rax
je 0x4bf9a
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x7c043
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x1502e
callq 0x14fc0
callq 0x14ff7