LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/meta_node.c
// Function: gt_meta_node_new
GtGenomeNode* gt_meta_node_new(const char *meta_directive,
                               const char *meta_data)
{
  GtGenomeNode *gn = gt_genome_node_create(gt_meta_node_class());
  GtMetaNode *m = gt_meta_node_cast(gn);
  gt_assert(meta_directive);
  m->meta_directive = gt_cstr_dup(meta_directive);
  if (meta_data)
    m->meta_data = gt_cstr_dup(meta_data);
  else
    m->meta_data = NULL;
  m->meta_str = gt_str_new_cstr("");
  return gn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
callq 0x488d4
movq %rax, %rdi
callq 0x414a6
movq %rax, %rbx
callq 0x488d4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4153f
testq %r12, %r12
je 0x48a64
movq %rax, %r15
movq %r12, %rdi
callq 0x728c0
movq %rax, 0x30(%r15)
testq %r14, %r14
je 0x48a3f
movq %r14, %rdi
callq 0x728c0
jmp 0x48a41
xorl %eax, %eax
movq %rax, 0x38(%r15)
leaq 0xa60eb(%rip), %rdi     # 0xeeb37
callq 0x3b785
movq %rax, 0x40(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1389a
// File: /workspace/github_c_makefile_star2_O3/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 0x10a0a1(%rip), %rax    # 0x152b60
testq %rax, %rax
je 0x48ac5
retq
pushq %rax
movq $0x0, (%rsp)
leaq 0x25(%rip), %rsi        # 0x48afa
leaq 0x46(%rip), %rcx        # 0x48b22
movl $0x18, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x48f24
movq %rax, 0x10a06b(%rip)    # 0x152b60
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x48b41
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x48b88
callq 0x48ab8
movq %rax, %rdi
movq %r15, %rsi
callq 0x48fc5
movq %rax, %r15
movq 0x10(%rax), %rdi
callq 0x7772d
leaq 0x6a(%rip), %rdx        # 0x48bce
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %ecx
movq %rbx, %r8
callq 0x3fd29
testl %eax, %eax
jne 0x48b83
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x139ad
callq 0x13976
// File: /workspace/github_c_makefile_star2_O3/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 0x48ab8
movq %rax, %rdi
callq 0x48f94
movq %rax, %rbx
callq 0x48ab8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x48fc5
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7740c
movq %rax, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3facd
testb %al, %al
je 0x48c40
movq 0x10(%r14), %r15
movq %rbx, %rdi
callq 0x3fc0c
movq %r15, %rdi
movq %rax, %rsi
callq 0x775ed
testq %rax, %rax
je 0x48c16
movq %rax, %r15
movq %rbx, %rdi
callq 0x3fbf4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3fb79
jmp 0x48c40
movq 0x10(%r14), %r14
movq %rbx, %rdi
callq 0x3fc0c
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x77628
movq %rbx, %rdi
callq 0x3fbf4
movq %rbx, %rdi
callq 0x3fb1b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x48c7b
movq %rdx, %rbx
testq %rdx, %rdx
je 0x48c7b
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x72274
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x139e4
// File: /workspace/github_c_makefile_star2_O3/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 0x48ce7
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x48ce7
leaq 0xa014a(%rip), %r15     # 0xe8deb
movl $0x1, %edi
movq %r15, %rdx
movl $0x38, %ecx
callq 0x359a6
movq %rax, %r12
movq %r14, (%rax)
movl $0x1, %edi
movl $0x10, %esi
movq %r15, %rdx
movl $0x3a, %ecx
callq 0x359a6
movq %rax, 0x8(%r12)
movb %bl, 0x8(%rax)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13a1b
// File: /workspace/github_c_makefile_star2_O3/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 0x48d1e
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl 0xc(%rax), %ecx
testl %ecx, %ecx
je 0x48d26
decl %ecx
movl %ecx, 0xc(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x48d77
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x48d40
movq %rbx, %rdi
callq *%rcx
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0x4210c
movq 0x8(%rbx), %rdi
leaq 0xa0098(%rip), %r14     # 0xe8deb
movq %r14, %rsi
movl $0x50, %edx
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x51, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
callq 0x13a89
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, 0x8(%rsp)
testq %rdi, %rdi
je 0x48e62
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x48e62
cmpq $0x0, 0x10(%rax)
je 0x48e62
movq %rdx, %r15
movq %rsi, %r14
testq %rdx, %rdx
je 0x48dcc
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0x48e67
movq 0x8(%rbx), %rsi
cmpq $0x0, (%rsi)
je 0x48e36
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq *0x10(%rax)
testl %eax, %eax
jne 0x48e46
movq 0x8(%rbx), %rdi
movq 0x8(%rsp), %rax
cmpb $0x1, 0x8(%rdi)
jne 0x48e25
cmpq $0x0, (%rdi)
setne %cl
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x48e25
leaq 0x8(%rsp), %rsi
callq 0x416ec
testl %eax, %eax
jg 0x48e6c
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 0x48e46
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rdx
callq *0x10(%rax)
testl %eax, %eax
je 0x48e50
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%rbx), %rdi
cmpq $0x0, (%rdi)
jne 0x48dd6
xorl %eax, %eax
jmp 0x48df4
callq 0x13b2e
callq 0x13ac0
callq 0x13af7
// File: /workspace/github_c_makefile_star2_O3/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 0x48eee
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x48e96
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x48ef3
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x48d7c
testl %eax, %eax
sete %cl
movq (%r15), %rdi
testq %rdi, %rdi
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x48ee4
leaq 0x8(%rsp), %r15
callq 0x4210c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x48d7c
testl %eax, %eax
jne 0x48ee4
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x48ec3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x13b9c
callq 0x13b65
// File: /workspace/github_c_makefile_star2_O3/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 0x48f7f
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x40, %edi
callq 0x72274
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 0x13c43
// File: /workspace/github_c_makefile_star2_O3/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 0x48fc0
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x48fc0
leaq 0x9ffa9(%rip), %rdx     # 0xe8f55
movl $0x1, %edi
movl $0x47, %ecx
callq 0x359a6
movq %rbx, (%rax)
popq %rbx
retq
callq 0x13cb1
// File: /workspace/github_c_makefile_star2_O3/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 0x48ffd
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x49035
testq %r15, %r15
je 0x49030
testq %r14, %r14
je 0x49030
movq (%r15), %rax
testq %rax, %rax
je 0x49030
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x49028
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 0x13d56
callq 0x13d1f
// File: /workspace/github_c_makefile_star2_O3/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 0x49059
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x49091
testq %r15, %r15
je 0x4908c
testq %r14, %r14
je 0x4908c
movq (%r15), %rax
testq %rax, %rax
je 0x4908c
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x49084
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 0x13dc4
callq 0x13d8d
// File: /workspace/github_c_makefile_star2_O3/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 0x490b5
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x490ed
testq %r15, %r15
je 0x490e8
testq %r14, %r14
je 0x490e8
movq (%r15), %rax
testq %rax, %rax
je 0x490e8
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x490e0
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 0x13e32
callq 0x13dfb
// File: /workspace/github_c_makefile_star2_O3/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 0x49111
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x49149
testq %r15, %r15
je 0x49144
testq %r14, %r14
je 0x49144
movq (%r15), %rax
testq %rax, %rax
je 0x49144
movq 0x28(%rax), %rax
testq %rax, %rax
je 0x4913c
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 0x13ea0
callq 0x13e69
// File: /workspace/github_c_makefile_star2_O3/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 0x4916d
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x491a5
testq %r15, %r15
je 0x491a0
testq %r14, %r14
je 0x491a0
movq (%r15), %rax
testq %rax, %rax
je 0x491a0
movq 0x30(%rax), %rax
testq %rax, %rax
je 0x49198
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 0x13f0e
callq 0x13ed7
// File: /workspace/github_c_makefile_star2_O3/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 0x491c9
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x49201
testq %r15, %r15
je 0x491fc
testq %r14, %r14
je 0x491fc
movq (%r15), %rax
testq %rax, %rax
je 0x491fc
movq 0x38(%rax), %rax
testq %rax, %rax
je 0x491f4
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 0x13f7e
callq 0x13f45
// File: /workspace/github_c_makefile_star2_O3/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 0x4923a
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x4923c
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x49225
movq %rbx, %rdi
callq *%rax
leaq 0x9fd29(%rip), %rsi     # 0xe8f55
movq %rbx, %rdi
movl $0x95, %edx
popq %rbx
jmp 0x35c27
popq %rbx
retq
callq 0x13fb7
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x9ff1f(%rip), %rsi     # 0xe916b
movl $0x18, %edi
movl $0x23, %edx
callq 0x35862
movq %rax, %rbx
callq 0x7c464
movq %rax, (%rbx)
callq 0x72f00
movq %rax, 0x8(%rbx)
callq 0x72f00
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x492d4
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x73273
movq 0x8(%rbx), %rdi
callq 0x73273
movq (%rbx), %rdi
callq 0x7c5d0
testq %rax, %rax
je 0x492b7
movq (%rbx), %rdi
callq 0x7c56e
movq %rax, %rdi
callq 0x4210c
jmp 0x49298
movq (%rbx), %rdi
callq 0x7ca47
leaq 0x9fea5(%rip), %rsi     # 0xe916b
movq %rbx, %rdi
movl $0x32, %edx
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x49310
movq %rdi, %rbx
movq (%rbx), %rdi
callq 0x7c5d0
testq %rax, %rax
je 0x492fd
movq (%rbx), %rdi
callq 0x7c56e
movq %rax, %rdi
callq 0x4210c
jmp 0x492de
movq 0x8(%rbx), %rdi
callq 0x730a0
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x730a0
callq 0x13ff0
// File: /workspace/github_c_makefile_star2_O3/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 0x493dc
movq %rsi, %r12
testq %rsi, %rsi
je 0x493dc
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
leaq 0x9e3e4(%rip), %rsi     # 0xe7726
movq %r12, %rdi
callq 0x3eedc
testq %rax, %rax
je 0x493e1
movq (%r14), %rdi
movq %r12, %rsi
callq 0x7c47f
testq %r15, %r15
je 0x49380
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x72fc5
testq %rax, %rax
jne 0x49380
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x72f66
testq %rbx, %rbx
je 0x493d0
movq %rbx, %rdi
callq 0x3cbed
testq %rax, %rax
je 0x493d0
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ca6f
movq %rax, %r12
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0x72fc5
testq %rax, %rax
jne 0x493c0
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x72f66
incq %r15
movq %rbx, %rdi
callq 0x3cbed
cmpq %rax, %r15
jb 0x49395
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x14027
callq 0x1405e
// File: /workspace/github_c_makefile_star2_O3/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 0x49422
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x7c5d0
testq %rax, %rax
je 0x4941e
movq (%rbx), %rdi
popq %rbx
jmp 0x7c56e
xorl %eax, %eax
popq %rbx
retq
callq 0x140cc
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0x1096ee(%rip)    # 0x152b68
jne 0x494c1
leaq 0x126(%rip), %rax       # 0x495a9
leaq 0xd6(%rip), %r10        # 0x49560
leaq 0x3e(%rip), %rsi        # 0x494cf
leaq 0x64(%rip), %rcx        # 0x494fc
leaq 0x77(%rip), %r8         # 0x49516
leaq 0x91(%rip), %r9         # 0x49537
movl $0x48, %edi
movq %rcx, %rdx
pushq %rax
pushq %r10
callq 0x41334
addq $0x10, %rsp
movq %rax, 0x1096a7(%rip)    # 0x152b68
callq 0x7237d
movq 0x10969b(%rip), %rax    # 0x152b68
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4946c
movq %rax, %rdi
movq %r14, %rsi
callq 0x4153f
testq %rbx, %rbx
je 0x495a4
movq %rax, %r14
testq %rax, %rax
je 0x495a4
movq 0x30(%r14), %rdi
callq 0x3c87b
movq %rbx, %rdi
callq 0x3bcaf
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x141a8
// File: /workspace/github_c_makefile_star2_O3/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 0x495c8
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x495eb
callq 0x4946c
movq %rax, %rdi
movq %r15, %rsi
callq 0x4153f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x490f2
callq 0x141df
// File: /workspace/github_c_makefile_star2_O3/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 0x4946c
movq %rax, %rdi
callq 0x414a6
movq %rax, %r12
callq 0x4946c
movq %rax, %rdi
movq %r12, %rsi
callq 0x4153f
testq %r15, %r15
je 0x49650
cmpq %rbx, %r14
ja 0x49655
movq %rax, %r13
movq %r15, %rdi
callq 0x3bcaf
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 0x1424d
callq 0x14216
// File: /workspace/github_c_makefile_star2_O3/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 0x496f1
movq %rsi, %r14
testq %rsi, %rsi
je 0x496f6
movq %rdi, %rbx
callq 0x415a1
movq %rax, %r15
movq %r14, %rdi
callq 0x415a1
movq %r15, %rdi
movq %rax, %rsi
callq 0x3bc02
testl %eax, %eax
jne 0x496fb
movq %rbx, %rdi
callq 0x415e5
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %r14, %rdi
callq 0x415e5
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r15, %rdi
callq 0x7e2af
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x41646
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x142f2
callq 0x142bb
callq 0x14284
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0x10944a(%rip)    # 0x152b70
jne 0x49769
leaq 0xda(%rip), %rax        # 0x49809
leaq 0x8a(%rip), %r10        # 0x497c0
leaq 0x3a(%rip), %rsi        # 0x49777
leaq 0x5d(%rip), %rcx        # 0x497a1
leaq 0x70(%rip), %r8         # 0x497bb
movl $0x40, %edi
movq %rcx, %rdx
xorl %r9d, %r9d
pushq %rax
pushq %r10
callq 0x41334
addq $0x10, %rsp
movq %rax, 0x109407(%rip)    # 0x152b70
callq 0x7237d
movq 0x1093fb(%rip), %rax    # 0x152b70
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x49718
movq %rax, %rdi
movq %r14, %rsi
callq 0x4153f
testq %rbx, %rbx
je 0x49804
movq %rax, %r14
testq %rax, %rax
je 0x49804
movq 0x30(%r14), %rdi
callq 0x3c87b
movq %rbx, %rdi
callq 0x3bcaf
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x14329
// File: /workspace/github_c_makefile_star2_O3/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 0x49828
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x4984b
callq 0x49718
movq %rax, %rdi
movq %r15, %rsi
callq 0x4153f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4914e
callq 0x14360
// File: /workspace/github_c_makefile_star2_O3/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 0x49718
movq %rax, %rdi
callq 0x414a6
movq %rax, %r14
callq 0x49718
movq %rax, %rdi
movq %r14, %rsi
callq 0x4153f
testq %r15, %r15
je 0x498b4
testq %rbx, %rbx
je 0x498b4
movq %rax, %r12
movq %r15, %rdi
callq 0x3b785
movq %rax, 0x30(%r12)
movq %rbx, %rdi
callq 0x3bcaf
movq %rax, 0x38(%r12)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x14397
// File: /workspace/github_c_makefile_star2_O3/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 0x499ca
movq %rsi, %rbx
testq %rsi, %rsi
je 0x499ca
movq %rdi, %r14
callq 0xb260
movq %rax, %r12
movq %rbx, %rdi
callq 0xb260
testq %r12, %r12
je 0x499cf
movq %rax, %r15
testq %rax, %rax
je 0x499cf
leaq 0x1(%r12), %r13
leaq (%r12,%r15), %rax
incq %rax
movq %rax, (%rsp)
leaq (%r12,%r15), %rdi
addq $0x3, %rdi
leaq 0x9fb0f(%rip), %rsi     # 0xe948e
movl $0x28, %edx
callq 0x35862
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 0x14473
callq 0x144aa
// File: /workspace/github_c_makefile_star2_O3/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 0x49acc
movq %rdx, %r14
testq %rdx, %rdx
je 0x49acc
movq %rsi, %r15
testq %rsi, %rsi
je 0x49acc
movq %rdi, %rbx
movq (%rdi), %rbp
testq %rbp, %rbp
je 0x49acc
movq %r15, %rdi
callq 0xb260
movq %rax, %r12
movq %r14, %rdi
callq 0xb260
testq %r12, %r12
je 0x49ad1
movq %rax, %r13
testq %rax, %rax
je 0x49ad1
movq %rsp, %rdx
movq %rbp, %rdi
movq %r15, %rsi
callq 0x49adb
testq %rax, %rax
jne 0x49ad6
movq (%rbx), %rdi
movq (%rsp), %rax
leaq (%r12,%r13), %rcx
leaq (%rax,%rcx), %rsi
addq $0x3, %rsi
leaq 0x9fa1e(%rip), %rdx     # 0xe948e
movl $0x83, %ecx
callq 0x35a9d
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 0x14551
callq 0x144e1
callq 0x14518
// File: /workspace/github_c_makefile_star2_O3/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
movb (%rdi), %r8b
incq %rsi
negq %rdi
cmpb %cl, %r8b
jne 0x49b18
incq %rax
movq %rsi, %r8
movl %ecx, %r9d
testb %r9b, %r9b
je 0x49b10
movb (%rax), %r9b
leaq 0x1(%r8), %r10
incq %rax
cmpb (%r8), %r9b
movq %r10, %r8
je 0x49af7
jmp 0x49b15
cmpb $0x0, (%rax)
jne 0x49b5c
decq %rax
leaq (%rdi,%rax), %r8
leaq 0x2(%rax), %r10
movq %r10, %r9
incq %r8
cmpb $0x0, (%rax)
leaq 0x1(%rax), %rax
leaq 0x1(%r10), %r10
jne 0x49b20
cmpb $0x0, (%rax)
je 0x49b52
cmpb $0x0, (%r9)
leaq 0x1(%r9), %r9
jne 0x49b38
movb (%r9), %r8b
leaq -0x1(%r9), %rax
testb %r8b, %r8b
cmovneq %r9, %rax
jmp 0x49ae9
testq %rdx, %rdx
je 0x49b5a
movq %r8, (%rdx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x49c6c
movq %rsi, %r15
testq %rsi, %rsi
je 0x49c6c
movq %rdi, %r13
movq (%rdi), %r12
xorl %eax, %eax
movq %r12, %rdx
xorl %ecx, %ecx
cmpb $0x0, (%rdx)
leaq 0x1(%rdx), %rdx
jne 0x49b8a
movzbl %cl, %esi
addq %rsi, %rax
cmpb $0x0, (%rdx)
je 0x49ba3
xorb $0x1, %cl
jmp 0x49b8a
cmpq $0x1, %rax
jbe 0x49c6c
movq %r15, %rdi
callq 0xb260
testq %rax, %rax
je 0x49c71
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x49adb
testq %rax, %rax
je 0x49c76
movq %rax, %r15
movq %rbx, %r14
negq %r14
movq %r13, (%rsp)
movq (%r13), %r13
movq %r13, %rbp
movq %rbp, %rax
incq %rbp
cmpb $0x0, (%rax)
jne 0x49beb
leaq 0x2(%rax), %rbp
cmpb $0x0, 0x1(%rax)
jne 0x49beb
notq %r13
addq %rbp, %r13
movq %r15, %rdi
callq 0xb260
movq %rax, %r12
leaq (%r15,%r14), %rdi
decq %rdi
leaq (%r15,%rax), %rsi
incq %rsi
addq %rax, %r15
notq %r15
addq %rbp, %r15
movq %r15, %rdx
callq 0xba60
movq (%rsp), %r14
movq (%r14), %rdi
addq %r12, %rbx
subq %rbx, %r13
leaq -0x1(%r13), %rsi
leaq 0x9f846(%rip), %rdx     # 0xe948e
movl $0x99, %ecx
callq 0x35a9d
movq %rax, (%r14)
cmpb $0x0, -0x2(%rax,%r13)
jne 0x49c7b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x14588
callq 0x14633
callq 0x145fa
callq 0x145c1
// File: /workspace/github_c_makefile_star2_O3/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 0x49ef1
movq %rsi, %r14
testq %rsi, %rsi
je 0x49ef1
movq %rdx, %rbx
movq %rdi, %r15
cmpb $0x0, (%r15)
leaq 0x1(%r15), %r15
jne 0x49ec7
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
movq %r15, %rdi
cmpb $0x0, (%rdi)
leaq 0x1(%rdi), %rdi
jne 0x49edd
cmpb $0x0, (%rdi)
jne 0x49ec4
popq %rbx
popq %r14
popq %r15
retq
callq 0x147fb
// File: /workspace/github_c_makefile_star2_O3/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 0x49f4c
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x9f772(%rip), %r14     # 0xe9680
movsbl (%rbx), %edi
testl %edi, %edi
sete %r15b
je 0x49f20
callq 0x3d3b0
jmp 0x49f30
movq %r14, %rdi
xorl %eax, %eax
callq 0xb070
testb $0x1, %bpl
jne 0x49f38
incq %rbx
movl %r15d, %ebp
jmp 0x49f0e
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3d3b0
callq 0x14834
// File: /workspace/github_c_makefile_star2_O3/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 0x49f68
callq 0x34fea
testb %al, %al
jne 0x4a06a
leaq 0x9f72d(%rip), %rdi     # 0xe969c
leaq 0x9f72c(%rip), %rsi     # 0xe96a2
callq 0x49920
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x9f720(%rip), %rsi     # 0xe96aa
leaq 0x9f71f(%rip), %rdx     # 0xe96b0
movq %rbx, %rdi
callq 0x499d4
leaq 0x9f718(%rip), %rsi     # 0xe96b8
leaq 0x9f717(%rip), %rdx     # 0xe96be
movq %rbx, %rdi
callq 0x499d4
movq (%rbx), %rdi
leaq 0x9f70d(%rip), %rsi     # 0xe96c6
callq 0x49e69
testq %rax, %rax
jne 0x4a056
movq 0x8(%rsp), %rdi
leaq 0x9f6c9(%rip), %rsi     # 0xe969c
callq 0x49e69
leaq 0x9f6c3(%rip), %rsi     # 0xe96a2
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4a05b
movq 0x8(%rsp), %rdi
leaq 0x9f6b3(%rip), %rsi     # 0xe96aa
callq 0x49e69
leaq 0x9f6ad(%rip), %rsi     # 0xe96b0
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4a060
movq 0x8(%rsp), %rdi
leaq 0x9f69d(%rip), %rsi     # 0xe96b8
callq 0x49e69
leaq 0x9f697(%rip), %rsi     # 0xe96be
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4a065
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4a04e
leaq 0x9f44a(%rip), %rsi     # 0xe948e
movl $0x199, %edx            # imm = 0x199
callq 0x35c27
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x148a6
callq 0x148df
callq 0x14918
callq 0x14951
callq 0x1486d
// File: /workspace/github_c_makefile_star2_O3/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 0x9e906(%rip), %rdi     # 0xe969c
leaq 0x9e905(%rip), %rsi     # 0xe96a2
callq 0x49920
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x9e8f9(%rip), %rsi     # 0xe96aa
leaq 0x9e8f8(%rip), %rdx     # 0xe96b0
movq %rbx, %rdi
callq 0x499d4
leaq 0x9e8f1(%rip), %rsi     # 0xe96b8
leaq 0x9e8f0(%rip), %rdx     # 0xe96be
movq %rbx, %rdi
callq 0x499d4
movq (%rbx), %rdi
leaq 0x9e8e6(%rip), %rsi     # 0xe96c6
callq 0x49e69
testq %rax, %rax
jne 0x4aeb3
movq 0x8(%rsp), %rdi
leaq 0x9e8a8(%rip), %rsi     # 0xe96a2
callq 0x49e69
testq %rax, %rax
jne 0x4aeb8
movq 0x8(%rsp), %rdi
leaq 0x9e89c(%rip), %rsi     # 0xe96b0
callq 0x49e69
testq %rax, %rax
jne 0x4aebd
movq 0x8(%rsp), %rdi
leaq 0x9e890(%rip), %rsi     # 0xe96be
callq 0x49e69
testq %rax, %rax
jne 0x4aec2
movq 0x8(%rsp), %rdi
leaq 0x9e854(%rip), %rsi     # 0xe969c
callq 0x49e69
leaq 0x9e84e(%rip), %rsi     # 0xe96a2
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4aec7
movq 0x8(%rsp), %rdi
leaq 0x9e83e(%rip), %rsi     # 0xe96aa
callq 0x49e69
leaq 0x9e838(%rip), %rsi     # 0xe96b0
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4aecc
movq 0x8(%rsp), %rdi
leaq 0x9e828(%rip), %rsi     # 0xe96b8
callq 0x49e69
leaq 0x9e822(%rip), %rsi     # 0xe96be
movq %rax, %rdi
callq 0xb890
testl %eax, %eax
jne 0x4aed1
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
retq
callq 0x14c6f
callq 0x14ca8
callq 0x14ce1
callq 0x14d1a
callq 0x14d53
callq 0x14d8c
callq 0x14dc5
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0x107c92(%rip)    # 0x152b78
jne 0x4af07
leaq 0x26(%rip), %rsi        # 0x4af15
leaq 0x49(%rip), %rdx        # 0x4af3f
movl $0x28, %edi
callq 0x48c48
movq %rax, 0x107c71(%rip)    # 0x152b78
callq 0x7237d
movq 0x107c65(%rip), %rax    # 0x152b78
popq %rcx
retq