LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multi_sanitizer_visitor.c
// Function: gt_multi_sanitizer_visitor_class
const GtNodeVisitorClass* gt_multi_sanitizer_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtMultiSanitizerVisitor),
                                    msv_free,
                                    NULL,
                                    msv_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  return nvc;
}

// Assembly:
movq 0x10a2e1(%rip), %rax    # 0x12fb50
testq %rax, %rax
je 0x25875
retq
pushq %rax
andq $0x0, (%rsp)
leaq 0x23(%rip), %rsi        # 0x258a5
leaq 0x75(%rip), %rcx        # 0x258fe
pushq $0x18
popq %rdi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x25f10
movq %rax, 0x10a2b0(%rip)    # 0x12fb50
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multi_sanitizer_visitor.c
// Function: msv_feature_node
static int msv_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                            GtError *err)
{
  GtMultiSanitizerVisitor *msv;
  int had_err = 0;
  gt_error_check(err);
  msv = msv_cast(nv);

  gt_hashmap_reset(msv->first_elems);
  had_err = gt_feature_node_traverse_children(fn, msv,
                                              msv_fixup_representatives,
                                              true, err);
  gt_assert(!had_err);   /* msv_fixup_representatives() is sane */

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x2591d
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x25987
callq 0x25868
movq %rax, %rdi
movq %r15, %rsi
callq 0x2603e
movq %rax, %r15
movq 0x10(%rax), %rdi
callq 0x56030
leaq 0xbe(%rip), %rdx        # 0x259fe
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %r8
callq 0x19e82
testl %eax, %eax
jne 0x2595d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x108654(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa46f8(%rip), %rsi     # 0xca066
leaq 0xa4c9e(%rip), %rdx     # 0xca613
leaq 0xac428(%rip), %rcx     # 0xd1da4
leaq 0xac3fa(%rip), %r8      # 0xd1d7d
pushq $0x51
jmp 0x259af
movq 0x10862a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa46ce(%rip), %rsi     # 0xca066
leaq 0xa4cba(%rip), %rdx     # 0xca659
leaq 0xac3fe(%rip), %rcx     # 0xd1da4
leaq 0xac3d0(%rip), %r8      # 0xd1d7d
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multi_sanitizer_visitor.c
// Function: gt_multi_sanitizer_visitor_new
GtNodeVisitor* gt_multi_sanitizer_visitor_new()
{
  GtNodeVisitor *nv =
                     gt_node_visitor_create(gt_multi_sanitizer_visitor_class());
  GtMultiSanitizerVisitor *msv = msv_cast(nv);
  msv->first_elems = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);

  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x25868
movq %rax, %rdi
callq 0x25fe0
movq %rax, %rbx
callq 0x25868
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2603e
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55da4
movq %rax, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/multi_sanitizer_visitor.c
// Function: msv_fixup_representatives
static int msv_fixup_representatives(GtFeatureNode *fn, void *data,
                                     GT_UNUSED GtError *err)
{
  int had_err = 0;
  GtMultiSanitizerVisitor *msv = (GtMultiSanitizerVisitor*) data;

  if (gt_feature_node_is_multi(fn)) {
    GtFeatureNode *rep = NULL;
    if (!(rep = gt_hashmap_get(msv->first_elems,
                               gt_feature_node_get_multi_representative(fn)))) {
      gt_hashmap_add(msv->first_elems,
                     gt_feature_node_get_multi_representative(fn),
                     fn);
      gt_feature_node_unset_multi(fn);
      gt_feature_node_make_multi_representative(fn);
    } else {
      gt_assert(rep);
      gt_feature_node_unset_multi(fn);
      gt_feature_node_set_multi_representative(fn, rep);
    }
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x198d7
testb %al, %al
je 0x25a70
movq 0x10(%r14), %r15
movq %rbx, %rdi
callq 0x19b8f
movq %r15, %rdi
movq %rax, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x25a46
movq %rax, %r15
movq %rbx, %rdi
callq 0x19b47
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19a6c
jmp 0x25a70
movq 0x10(%r14), %r14
movq %rbx, %rdi
callq 0x19b8f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x55f31
movq %rbx, %rdi
callq 0x19b47
movq %rbx, %rdi
callq 0x199db
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/node_stream.c
// Function: gt_node_stream_class_new
const GtNodeStreamClass*
gt_node_stream_class_new(size_t size, GtNodeStreamFreeFunc free,
                         GtNodeStreamNextFunc next)
{
  GtNodeStreamClass *c_class;
  gt_assert(size && next);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->next = next;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x25aa9
movq %rdx, %rbx
testq %rdx, %rdx
je 0x25aa9
movq %rsi, %r14
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x4f148
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
movq 0x108508(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa45ac(%rip), %rsi     # 0xca066
leaq 0xac2f4(%rip), %rdx     # 0xd1db5
leaq 0xac2fa(%rip), %rcx     # 0xd1dc2
leaq 0xac30c(%rip), %r8      # 0xd1ddb
pushq $0x2b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x25b3e
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x25b3e
leaq 0xac2da(%rip), %r15     # 0xd1ddb
pushq $0x1
popq %r12
pushq $0x38
popq %rcx
movq %r12, %rdi
movq %r15, %rdx
callq 0xce9a
movq %rax, %r13
movq %r14, (%rax)
pushq $0x10
popq %rsi
pushq $0x3a
popq %rcx
movq %r12, %rdi
movq %r15, %rdx
callq 0xce9a
movq %rax, 0x8(%r13)
movb %bl, 0x8(%rax)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x108473(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa4517(%rip), %rsi     # 0xca066
leaq 0xac2a0(%rip), %rdx     # 0xd1df6
leaq 0xac2aa(%rip), %rcx     # 0xd1e07
leaq 0xac277(%rip), %r8      # 0xd1ddb
pushq $0x37
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x25bd7
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0xc(%rax), %ecx
testl %ecx, %ecx
je 0x25bdf
decl %ecx
movl %ecx, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x25c2c
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x25bf9
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0x1d1e3
movq 0x8(%rbx), %rdi
leaq 0xac1cf(%rip), %r14     # 0xd1ddb
pushq $0x50
popq %rdx
movq %r14, %rsi
callq 0xd249
pushq $0x51
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
movq 0x108385(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa4429(%rip), %rsi     # 0xca066
leaq 0xac1ec(%rip), %rdx     # 0xd1e30
leaq 0xac1f1(%rip), %rcx     # 0xd1e3c
leaq 0xac189(%rip), %r8      # 0xd1ddb
pushq $0x4d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
andq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x25d49
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x25d49
cmpq $0x0, 0x10(%rax)
je 0x25d49
movq %rdx, %r15
movq %rsi, %r14
testq %rdx, %rdx
je 0x25caf
movq %r15, %rdi
callq 0xc103
testb %al, %al
jne 0x25d7f
movq 0x8(%rbx), %rsi
cmpq $0x0, (%rsi)
je 0x25d1d
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0x10(%rax)
testl %eax, %eax
jne 0x25d2d
movq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rax
cmpb $0x1, 0x8(%rdi)
jne 0x25d0c
cmpq $0x0, (%rdi)
setne %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x25d0c
leaq 0x8(%rsp), %rsi
callq 0x1c61c
testl %eax, %eax
jg 0x25da9
movq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rax
movq (%rdi), %rcx
movq %rcx, (%r14)
movq 0x8(%rbx), %rcx
movq %rax, (%rcx)
xorl %eax, %eax
jmp 0x25d2d
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rdx
callq *0x10(%rax)
testl %eax, %eax
je 0x25d37
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rdi
cmpq $0x0, (%rdi)
jne 0x25cb9
xorl %eax, %eax
jmp 0x25cd7
movq 0x108268(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa430c(%rip), %rsi     # 0xca066
leaq 0xac0f1(%rip), %rdx     # 0xd1e52
leaq 0xac111(%rip), %rcx     # 0xd1e79
leaq 0xac06c(%rip), %r8      # 0xd1ddb
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x108232(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa42d6(%rip), %rsi     # 0xca066
leaq 0xa48c2(%rip), %rdx     # 0xca659
leaq 0xac0db(%rip), %rcx     # 0xd1e79
leaq 0xac036(%rip), %r8      # 0xd1ddb
pushq $0x59
jmp 0x25d71
movq 0x108208(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa42ac(%rip), %rsi     # 0xca066
leaq 0xac0cc(%rip), %rdx     # 0xd1e8d
leaq 0xac0b1(%rip), %rcx     # 0xd1e79
leaq 0xac00c(%rip), %r8      # 0xd1ddb
pushq $0x63
jmp 0x25d71
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x25e1d
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x25df3
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x25e47
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25c62
testl %eax, %eax
jne 0x25e15
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x25e15
callq 0x1d1e3
jmp 0x25df3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x108194(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa4238(%rip), %rsi     # 0xca066
leaq 0xc17c0(%rip), %rdx     # 0xe75f5
leaq 0xac08e(%rip), %rcx     # 0xd1eca
leaq 0xabf98(%rip), %r8      # 0xd1ddb
pushq $0x72
jmp 0x25e6f
movq 0x10816a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa420e(%rip), %rsi     # 0xca066
leaq 0xa47fa(%rip), %rdx     # 0xca659
leaq 0xac064(%rip), %rcx     # 0xd1eca
leaq 0xabf6e(%rip), %r8      # 0xd1ddb
pushq $0x73
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x25f69
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
pushq $0x40
popq %rdi
callq 0x4f148
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
movq 0x108048(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa40ec(%rip), %rsi     # 0xca066
leaq 0xb3874(%rip), %rdx     # 0xd97f5
leaq 0xabfa3(%rip), %rcx     # 0xd1f2b
leaq 0xabfb6(%rip), %r8      # 0xd1f45
pushq $0x2f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x26008
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x26008
leaq 0xabf4d(%rip), %rdx     # 0xd1f45
pushq $0x1
popq %rdi
pushq $0x47
popq %rcx
callq 0xce9a
movq %rbx, (%rax)
popq %rbx
retq
movq 0x107fa9(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa404d(%rip), %rsi     # 0xca066
leaq 0xabf6a(%rip), %rdx     # 0xd1f8a
leaq 0xabf74(%rip), %rcx     # 0xd1f9b
leaq 0xabf17(%rip), %r8      # 0xd1f45
pushq $0x46
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x260a7
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x26104
testq %r15, %r15
je 0x260da
testq %r14, %r14
je 0x260da
movq (%r15), %rax
testq %rax, %rax
je 0x260da
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x260d2
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
movq 0x107ed7(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3f7b(%rip), %rsi     # 0xca066
leaq 0xabf18(%rip), %rdx     # 0xd200a
leaq 0xabeee(%rip), %rcx     # 0xd1fe7
leaq 0xabe45(%rip), %r8      # 0xd1f45
pushq $0x57
jmp 0x2612c
movq 0x107ead(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3f51(%rip), %rsi     # 0xca066
leaq 0xa453d(%rip), %rdx     # 0xca659
leaq 0xabec4(%rip), %rcx     # 0xd1fe7
leaq 0xabe1b(%rip), %r8      # 0xd1f45
pushq $0x56
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x26159
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x261b6
testq %r15, %r15
je 0x2618c
testq %r14, %r14
je 0x2618c
movq (%r15), %rax
testq %rax, %rax
je 0x2618c
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x26184
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
movq 0x107e25(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3ec9(%rip), %rsi     # 0xca066
leaq 0xabea1(%rip), %rdx     # 0xd2045
leaq 0xabe77(%rip), %rcx     # 0xd2022
leaq 0xabd93(%rip), %r8      # 0xd1f45
pushq $0x61
jmp 0x261de
movq 0x107dfb(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3e9f(%rip), %rsi     # 0xca066
leaq 0xa448b(%rip), %rdx     # 0xca659
leaq 0xabe4d(%rip), %rcx     # 0xd2022
leaq 0xabd69(%rip), %r8      # 0xd1f45
pushq $0x60
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2620b
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x26268
testq %r15, %r15
je 0x2623e
testq %r14, %r14
je 0x2623e
movq (%r15), %rax
testq %rax, %rax
je 0x2623e
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x26236
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
movq 0x107d73(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3e17(%rip), %rsi     # 0xca066
leaq 0xabe27(%rip), %rdx     # 0xd207d
leaq 0xabe00(%rip), %rcx     # 0xd205d
leaq 0xabce1(%rip), %r8      # 0xd1f45
pushq $0x6b
jmp 0x26290
movq 0x107d49(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3ded(%rip), %rsi     # 0xca066
leaq 0xa43d9(%rip), %rdx     # 0xca659
leaq 0xabdd6(%rip), %rcx     # 0xd205d
leaq 0xabcb7(%rip), %r8      # 0xd1f45
pushq $0x6a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x262bd
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x2631a
testq %r15, %r15
je 0x262f0
testq %r14, %r14
je 0x262f0
movq (%r15), %rax
testq %rax, %rax
je 0x262f0
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x262e8
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
movq 0x107cc1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3d65(%rip), %rsi     # 0xca066
leaq 0xabdaf(%rip), %rdx     # 0xd20b7
leaq 0xabd86(%rip), %rcx     # 0xd2095
leaq 0xabc2f(%rip), %r8      # 0xd1f45
pushq $0x75
jmp 0x26342
movq 0x107c97(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3d3b(%rip), %rsi     # 0xca066
leaq 0xa4327(%rip), %rdx     # 0xca659
leaq 0xabd5c(%rip), %rcx     # 0xd2095
leaq 0xabc05(%rip), %r8      # 0xd1f45
pushq $0x74
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x2636f
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x263cc
testq %r15, %r15
je 0x263a2
testq %r14, %r14
je 0x263a2
movq (%r15), %rax
testq %rax, %rax
je 0x263a2
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x2639a
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
movq 0x107c0f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3cb3(%rip), %rsi     # 0xca066
leaq 0xabd39(%rip), %rdx     # 0xd20f3
leaq 0xabd0e(%rip), %rcx     # 0xd20cf
leaq 0xabb7d(%rip), %r8      # 0xd1f45
pushq $0x7f
jmp 0x263f4
movq 0x107be5(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3c89(%rip), %rsi     # 0xca066
leaq 0xa4275(%rip), %rdx     # 0xca659
leaq 0xabce4(%rip), %rcx     # 0xd20cf
leaq 0xabb53(%rip), %r8      # 0xd1f45
pushq $0x7e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x26421
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x26482
testq %r15, %r15
je 0x26454
testq %r14, %r14
je 0x26454
movq (%r15), %rax
testq %rax, %rax
je 0x26454
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x2644c
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
movq 0x107b5d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3c01(%rip), %rsi     # 0xca066
leaq 0xabcbe(%rip), %rdx     # 0xd212a
leaq 0xabc98(%rip), %rcx     # 0xd210b
leaq 0xabacb(%rip), %r8      # 0xd1f45
movl $0x89, %r9d
jmp 0x264ae
movq 0x107b2f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3bd3(%rip), %rsi     # 0xca066
leaq 0xa41bf(%rip), %rdx     # 0xca659
leaq 0xabc6a(%rip), %rcx     # 0xd210b
leaq 0xaba9d(%rip), %r8      # 0xd1f45
movl $0x88, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x264ee
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x264f0
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x264d9
movq %rbx, %rdi
callq *%rax
leaq 0xaba65(%rip), %rsi     # 0xd1f45
movq %rbx, %rdi
movl $0x95, %edx
popq %rbx
jmp 0xd249
popq %rbx
retq
movq 0x107ac1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3b65(%rip), %rsi     # 0xca066
leaq 0xabb0e(%rip), %rdx     # 0xd2016
leaq 0xabc35(%rip), %rcx     # 0xd2144
leaq 0xaba2f(%rip), %r8      # 0xd1f45
movl $0x92, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xabc2b(%rip), %rsi     # 0xd215b
pushq $0x18
popq %rdi
pushq $0x23
popq %rdx
callq 0xccb0
movq %rax, %rbx
callq 0x5b040
movq %rax, (%rbx)
callq 0x5005c
movq %rax, 0x8(%rbx)
callq 0x5005c
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x265af
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x5055b
movq 0x8(%rbx), %rdi
callq 0x5055b
movq (%rbx), %rdi
callq 0x5b20f
movq (%rbx), %rdi
testq %rax, %rax
je 0x26597
callq 0x5b195
movq %rax, %rdi
callq 0x1d1e3
jmp 0x26578
callq 0x5b761
leaq 0xabbb8(%rip), %rsi     # 0xd215b
pushq $0x32
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x265eb
movq %rdi, %rbx
movq (%rbx), %rdi
callq 0x5b20f
testq %rax, %rax
je 0x265d8
movq (%rbx), %rdi
callq 0x5b195
movq %rax, %rdi
callq 0x1d1e3
jmp 0x265b9
movq 0x8(%rbx), %rdi
callq 0x50373
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x50373
movq 0x1079c6(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3a6a(%rip), %rsi     # 0xca066
leaq 0xa7571(%rip), %rdx     # 0xcdb74
leaq 0xabb6a(%rip), %rcx     # 0xd2174
leaq 0xabb4a(%rip), %r8      # 0xd215b
pushq $0x37
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x266dd
movq %rsi, %r12
testq %rsi, %rsi
je 0x266dd
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
leaq 0xaa0c8(%rip), %rsi     # 0xd0716
movq %r12, %rdi
callq 0x18818
testq %rax, %rax
je 0x26707
movq (%r14), %rdi
movq %r12, %rsi
callq 0x5b055
testq %r15, %r15
je 0x2668c
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x5018a
testq %rax, %rax
jne 0x2668c
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x500bc
testq %rbx, %rbx
je 0x266d1
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x157f4
cmpq %rax, %r15
jae 0x266d1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1555e
movq %rax, %r12
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0x5018a
testq %rax, %rax
jne 0x266cc
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x500bc
incq %r15
jmp 0x26694
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1078d4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3978(%rip), %rsi     # 0xca066
leaq 0xaba92(%rip), %rdx     # 0xd2187
leaq 0xaba97(%rip), %rcx     # 0xd2193
leaq 0xaba58(%rip), %r8      # 0xd215b
pushq $0x43
jmp 0x2672f
movq 0x1078aa(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa394e(%rip), %rsi     # 0xca066
leaq 0xaba85(%rip), %rdx     # 0xd21a4
leaq 0xaba6d(%rip), %rcx     # 0xd2193
leaq 0xaba2e(%rip), %r8      # 0xd215b
pushq $0x45
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x267aa
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x5b20f
testq %rax, %rax
je 0x267a6
movq (%rbx), %rdi
popq %rbx
jmp 0x5b195
xorl %eax, %eax
popq %rbx
retq
movq 0x107807(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa38ab(%rip), %rsi     # 0xca066
leaq 0xa73b2(%rip), %rdx     # 0xcdb74
leaq 0xaba48(%rip), %rcx     # 0xd2211
leaq 0xab98b(%rip), %r8      # 0xd215b
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4f21f
cmpq $0x0, 0x1092c6(%rip)    # 0x12fb58
jne 0x268d5
leaq 0x135(%rip), %rax       # 0x269d0
leaq 0xc2(%rip), %r10        # 0x26964
leaq 0x3a(%rip), %rsi        # 0x268e3
leaq 0x83(%rip), %rcx        # 0x26933
leaq 0x88(%rip), %r8         # 0x2693f
leaq 0x94(%rip), %r9         # 0x26952
pushq $0x48
popq %rdi
movq %rcx, %rdx
pushq %rax
pushq %r10
callq 0x1bf21
popq %rcx
popq %rdx
movq %rax, 0x109283(%rip)    # 0x12fb58
callq 0x4f266
movq 0x109277(%rip), %rax    # 0x12fb58
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x26af8
testq %rbx, %rbx
je 0x2699a
movq %rax, %r14
testq %rax, %rax
je 0x2699a
movq 0x30(%r14), %rdi
callq 0x152db
movq %rbx, %rdi
callq 0x146aa
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x107617(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa36bb(%rip), %rsi     # 0xca066
leaq 0xab995(%rip), %rdx     # 0xd2347
leaq 0xab99a(%rip), %rcx     # 0xd2353
leaq 0xab8ba(%rip), %r8      # 0xd227a
pushq $0x3b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x269ef
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x26a0a
movq %r15, %rdi
callq 0x26af8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2629e
movq 0x1075a7(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa364b(%rip), %rsi     # 0xca066
leaq 0xa3c37(%rip), %rdx     # 0xca659
leaq 0xab943(%rip), %rcx     # 0xd236c
leaq 0xab84a(%rip), %r8      # 0xd227a
pushq $0x43
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x26884
movq %rax, %rdi
callq 0x1c0f3
movq %rax, %r12
movq %rax, %rdi
callq 0x26af8
testq %r15, %r15
je 0x26a98
cmpq %rbx, %r14
ja 0x26ac2
movq %rax, %r13
movq %r15, %rdi
callq 0x146aa
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
movq 0x107519(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa35bd(%rip), %rsi     # 0xca066
leaq 0xc44c0(%rip), %rdx     # 0xeaf70
leaq 0xab7b0(%rip), %rcx     # 0xd2267
leaq 0xab7bc(%rip), %r8      # 0xd227a
pushq $0x5f
jmp 0x26aea
movq 0x1074ef(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3593(%rip), %rsi     # 0xca066
leaq 0xb3bc4(%rip), %rdx     # 0xda69e
leaq 0xab786(%rip), %rcx     # 0xd2267
leaq 0xab792(%rip), %r8      # 0xd227a
pushq $0x60
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x26b97
movq %rsi, %r14
testq %rsi, %rsi
je 0x26bc1
movq %rdi, %rbx
callq 0x1c31a
movq %rax, %r15
movq %r14, %rdi
callq 0x1c31a
movq %r15, %rdi
movq %rax, %rsi
callq 0x14573
testl %eax, %eax
jne 0x26beb
movq %rbx, %rdi
callq 0x1c3c4
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %r14, %rdi
callq 0x1c3c4
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r15, %rdi
callq 0x5d269
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1c48b
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x10741a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa34be(%rip), %rsi     # 0xca066
leaq 0xab6e6(%rip), %rdx     # 0xd2295
leaq 0xab6e4(%rip), %rcx     # 0xd229a
leaq 0xab6bd(%rip), %r8      # 0xd227a
pushq $0x6a
jmp 0x26c13
movq 0x1073f0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3494(%rip), %rsi     # 0xca066
leaq 0xab6dc(%rip), %rdx     # 0xd22b5
leaq 0xab6ba(%rip), %rcx     # 0xd229a
leaq 0xab693(%rip), %r8      # 0xd227a
pushq $0x6b
jmp 0x26c13
movq 0x1073c6(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa346a(%rip), %rsi     # 0xca066
leaq 0xab6b7(%rip), %rdx     # 0xd22ba
leaq 0xab690(%rip), %rcx     # 0xd229a
leaq 0xab669(%rip), %r8      # 0xd227a
pushq $0x6d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4f21f
cmpq $0x0, 0x108f1a(%rip)    # 0x12fb60
jne 0x26c85
leaq 0xdd(%rip), %rax        # 0x26d2c
leaq 0x6a(%rip), %r10        # 0x26cc0
leaq 0x36(%rip), %rsi        # 0x26c93
leaq 0x4b(%rip), %rcx        # 0x26caf
leaq 0x50(%rip), %r8         # 0x26cbb
pushq $0x40
popq %rdi
movq %rcx, %rdx
xorl %r9d, %r9d
pushq %rax
pushq %r10
callq 0x1bf21
popq %rcx
popq %rdx
movq %rax, 0x108edb(%rip)    # 0x12fb60
callq 0x4f266
movq 0x108ecf(%rip), %rax    # 0x12fb60
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x26e2e
testq %rbx, %rbx
je 0x26cf6
movq %rax, %r14
testq %rax, %rax
je 0x26cf6
movq 0x30(%r14), %rdi
callq 0x152db
movq %rbx, %rdi
callq 0x146aa
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1072bb(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa335f(%rip), %rsi     # 0xca066
leaq 0xab71f(%rip), %rdx     # 0xd242d
leaq 0xab724(%rip), %rcx     # 0xd2439
leaq 0xab690(%rip), %r8      # 0xd23ac
pushq $0x35
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x26d4b
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x26d66
movq %r15, %rdi
callq 0x26e2e
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x26350
movq 0x10724b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa32ef(%rip), %rsi     # 0xca066
leaq 0xa38db(%rip), %rdx     # 0xca659
leaq 0xab6cf(%rip), %rcx     # 0xd2454
leaq 0xab620(%rip), %r8      # 0xd23ac
pushq $0x3e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x26c38
movq %rax, %rdi
callq 0x1c0f3
movq %rax, %r14
movq %rax, %rdi
callq 0x26e2e
testq %r15, %r15
je 0x26df8
testq %rbx, %rbx
je 0x26df8
movq %rax, %r12
movq %r15, %rdi
callq 0x13da9
movq %rax, 0x30(%r12)
movq %rbx, %rdi
callq 0x146aa
movq %rax, 0x38(%r12)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1071b9(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa325d(%rip), %rsi     # 0xca066
leaq 0xab56f(%rip), %rdx     # 0xd237f
leaq 0xab580(%rip), %rcx     # 0xd2397
leaq 0xab58e(%rip), %r8      # 0xd23ac
pushq $0x59
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x26fd5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x26fd5
movq %rdi, %r14
callq 0xb260
movq %rax, %r12
movq %rbx, %rdi
callq 0xb260
testq %r12, %r12
je 0x26fff
movq %rax, %r15
testq %rax, %rax
je 0x26fff
leaq 0x1(%r12), %r13
leaq (%r12,%r15), %rax
incq %rax
movq %rax, (%rsp)
leaq 0x3(%r12,%r15), %rdi
leaq 0xab4f2(%rip), %rsi     # 0xd247e
pushq $0x28
popq %rdx
callq 0xccb0
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
movq 0x106fdc(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3080(%rip), %rsi     # 0xca066
leaq 0xb74d0(%rip), %rdx     # 0xde4bd
leaq 0xab475(%rip), %rcx     # 0xd2469
leaq 0xab483(%rip), %r8      # 0xd247e
pushq $0x24
jmp 0x27027
movq 0x106fb2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa3056(%rip), %rsi     # 0xca066
leaq 0xab484(%rip), %rdx     # 0xd249b
leaq 0xab44b(%rip), %rcx     # 0xd2469
leaq 0xab459(%rip), %r8      # 0xd247e
pushq $0x27
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
testq %rdi, %rdi
je 0x2712a
movq %rdx, %r14
testq %rdx, %rdx
je 0x2712a
movq %rsi, %r15
testq %rsi, %rsi
je 0x2712a
movq %rdi, %rbx
movq (%rdi), %rbp
testq %rbp, %rbp
je 0x2712a
movq %r15, %rdi
callq 0xb260
movq %rax, %r12
movq %r14, %rdi
callq 0xb260
testq %r12, %r12
je 0x27154
movq %rax, %r13
testq %rax, %rax
je 0x27154
movq %rsp, %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x271b8
testq %rax, %rax
jne 0x27180
movq (%rbx), %rdi
movq (%rsp), %rax
leaq (%r12,%r13), %rcx
leaq (%rax,%rcx), %rsi
addq $0x3, %rsi
leaq 0xab3b0(%rip), %rdx     # 0xd247e
movl $0x83, %ecx
callq 0xcfc2
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
movq 0x106e87(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2f2b(%rip), %rsi     # 0xca066
leaq 0xab36e(%rip), %rdx     # 0xd24b0
leaq 0xab383(%rip), %rcx     # 0xd24cc
leaq 0xab32e(%rip), %r8      # 0xd247e
pushq $0x7b
jmp 0x2717c
movq 0x106e5d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2f01(%rip), %rsi     # 0xca066
leaq 0xab32f(%rip), %rdx     # 0xd249b
leaq 0xab359(%rip), %rcx     # 0xd24cc
leaq 0xab304(%rip), %r8      # 0xd247e
pushq $0x7e
popq %r9
jmp 0x271ac
movq 0x106e31(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa2ed5(%rip), %rsi     # 0xca066
leaq 0xab349(%rip), %rdx     # 0xd24e1
leaq 0xab32d(%rip), %rcx     # 0xd24cc
leaq 0xab2d8(%rip), %r8      # 0xd247e
movl $0x81, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, %rcx
negq %rcx
movq %rsi, %r8
movq %rdi, %rax
movb (%rdi), %r9b
cmpb (%r8), %r9b
jne 0x271dd
incq %r8
leaq 0x1(%rax), %rdi
testb %r9b, %r9b
jne 0x271c1
cmpb $0x0, (%rdi)
jne 0x2721a
leaq (%rcx,%rax), %rdi
incq %rdi
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
jne 0x271e1
cmpb $0x0, (%rax)
je 0x2720f
movb $0x1, %r8b
testb %r8b, %r8b
movb 0x1(%rax), %r8b
leaq 0x1(%rax), %rax
jne 0x271f5
leaq -0x1(%rax), %rdi
testb %r8b, %r8b
cmovneq %rax, %rdi
jmp 0x271be
testq %rdx, %rdx
je 0x27217
movq %rdi, (%rdx)
xorl %eax, %eax
retq
incq %rax
retq