LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/snp_annotator_visitor.c
// Function: gt_snp_annotator_visitor_class
const GtNodeVisitorClass* gt_snp_annotator_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSNPAnnotatorVisitor),
                                    snp_annotator_visitor_free,
                                    NULL,
                                    snp_annotator_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x34c4a2(%rip)    # 0x4c9898
jne 0x17d427
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x17d435
leaq 0x6f(%rip), %rcx        # 0x17d47d
movl $0x58, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x34c471(%rip)    # 0x4c9898
callq 0xe6a19
movq 0x34c465(%rip), %rax    # 0x4c9898
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/snp_annotator_visitor.c
// Function: snp_annotator_visitor_free
static void snp_annotator_visitor_free(GtNodeVisitor *nv)
{
  GtSNPAnnotatorVisitor *sav;
  if (!nv) return;
  sav = snp_annotator_visitor_cast(nv);
  gt_genome_node_delete((GtGenomeNode*) sav->gene);
  if (sav->own_tt)
    gt_trans_table_delete(sav->tt);
  gt_region_mapping_delete(sav->rmap);
  gt_hashmap_delete(sav->rnaseqs);
}

// Assembly:
testq %rdi, %rdi
je 0x17d47c
pushq %rbx
movq %rdi, %rbx
callq 0x17d3e8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x14c43a
cmpb $0x1, 0x30(%rbx)
jne 0x17d469
movq 0x28(%rbx), %rdi
callq 0x124000
movq 0x18(%rbx), %rdi
callq 0x1758da
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x105f7d
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_results_new
GtSpecResults *gt_spec_results_new(void)
{
  GtSpecResults *spec_results;
  spec_results = gt_calloc(1, sizeof (GtSpecResults));
  spec_results->feature_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                                 (GtFree) gt_hashmap_delete);
  spec_results->meta_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                              (GtFree) gt_spec_aspect_delete);
  spec_results->sequence_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                               (GtFree) gt_spec_aspect_delete);
  spec_results->region_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                               (GtFree) gt_spec_aspect_delete);
  spec_results->comment_aspects = gt_hashmap_new(GT_HASH_STRING, NULL,
                                               (GtFree) gt_spec_aspect_delete);
  spec_results->warnings = gt_str_array_new();
  spec_results->has_runtime_errors = spec_results->has_failures = false;
  return spec_results;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x21e7a9(%rip), %rdx    # 0x39c9f8
movl $0x1, %edi
movl $0x58, %esi
movl $0x98, %ecx
callq 0x1093ef
movq %rax, %rbx
leaq -0x782f0(%rip), %rdx    # 0x105f7d
movl $0x1, %edi
xorl %esi, %esi
callq 0x105830
movq %rax, (%rbx)
leaq 0x66(%rip), %r14        # 0x17e2e9
movl $0x1, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x105830
movq %rax, 0x8(%rbx)
movl $0x1, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x105830
movq %rax, 0x20(%rbx)
movl $0x1, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x105830
movq %rax, 0x10(%rbx)
movl $0x1, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x105830
movq %rax, 0x18(%rbx)
callq 0x121b54
movq %rax, 0x50(%rbx)
movw $0x0, 0x2d(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_aspect_delete
static void gt_spec_aspect_delete(GtSpecAspect *sa)
{
  if (!sa) return;
  gt_str_delete(sa->name);
  gt_hashmap_delete(sa->aspect_node_results);
  gt_free(sa);
}

// Assembly:
testq %rdi, %rdi
je 0x17e318
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x121b03
movq (%rbx), %rdi
callq 0x105f7d
leaq 0x21e6ee(%rip), %rsi    # 0x39c9f8
movq %rbx, %rdi
movl $0x92, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_aspect_new
static GtSpecAspect* gt_spec_aspect_new(const char *name)
{
  GtSpecAspect *sa;
  gt_assert(name);

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

  return sa;
}

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

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

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

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

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x17effe
movq %rdi, %rbx
leaq 0x34626e(%rip), %rsi    # 0x4c51f0
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
movq %rax, %r14
movq %rbx, %rdi
callq 0x22d421
testl %eax, %eax
jle 0x17eff1
leaq 0x25321a(%rip), %r15    # 0x3d21d1
xorl %ebp, %ebp
incl %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x22d88c
testl %eax, %eax
je 0x17efe5
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x22db9e
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x103d21
movq %rbx, %rdi
callq 0x22d421
cmpl %eax, %ebp
jl 0x17efb9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x56305
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_results_delete
void gt_spec_results_delete(GtSpecResults *spec_results)
{
  if (!spec_results) return;
  gt_hashmap_delete(spec_results->feature_aspects);
  gt_hashmap_delete(spec_results->meta_aspects);
  gt_hashmap_delete(spec_results->comment_aspects);
  gt_hashmap_delete(spec_results->sequence_aspects);
  gt_hashmap_delete(spec_results->region_aspects);
  gt_str_array_delete(spec_results->warnings);
  gt_free(spec_results);
}

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

// Assembly:
testq %rdi, %rdi
je 0x17f086
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121e8b
movq 0x8(%rbx), %rdi
callq 0x121e8b
leaq 0x21d980(%rip), %rsi    # 0x39c9f8
movq %rbx, %rdi
movl $0x7b, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_results.c
// Function: gt_spec_aspect_node_result_new
static GtSpecAspectNodeResult* gt_spec_aspect_node_result_new()
{
  GtSpecAspectNodeResult *sanr;

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

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

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

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

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x34a4ce(%rip)    # 0x4c98a8
jne 0x17f427
movq $0x0, (%rsp)
leaq 0x4a(%rip), %rsi        # 0x17f435
leaq 0x85(%rip), %rdx        # 0x17f477
leaq 0x145(%rip), %rcx       # 0x17f53e
leaq 0x207(%rip), %r8        # 0x17f607
leaq 0x2c7(%rip), %r9        # 0x17f6ce
movl $0x78, %edi
callq 0x16ae80
movq %rax, 0x34a490(%rip)    # 0x4c98a8
leaq 0x376(%rip), %rsi       # 0x17f795
movq %rax, %rdi
callq 0x16aee0
callq 0xe6a19
movq 0x34a475(%rip), %rax    # 0x4c98a8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_free
static void spec_visitor_free(GtNodeVisitor* nv)
{
  GtSpecVisitor *sv;
  if (!nv) return;
  sv = spec_visitor_cast(nv);
  gt_str_delete(sv->filename);
  lua_close(sv->L);
  gt_hashmap_delete(sv->type_specs);
  gt_array_delete(sv->graph_context);
}

// Assembly:
testq %rdi, %rdi
je 0x17f476
pushq %rbx
movq %rdi, %rbx
callq 0x17f3cc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x2307b5
movq 0x20(%rbx), %rdi
callq 0x105f7d
movq 0x60(%rbx), %rdi
popq %rbx
jmp 0xd4ef4
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_comment_node
static int spec_visitor_comment_node(GtNodeVisitor *nv, GtCommentNode *cn,
                                     GtError *err)
{
  int had_err = 0;
  GtSpecVisitor *sv;
  gt_error_check(err);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x17f49d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17f539
callq 0x17f3cc
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
movl 0x38(%rax), %edx
xorl %ebp, %ebp
movl %edx, %eax
negl %eax
jo 0x17f525
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e852
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x14b5fc
movq %r12, %rdi
movq %rax, %rsi
callq 0x18f4ad
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f092
testl %eax, %eax
je 0x17f525
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
leaq 0x252cb9(%rip), %rsi    # 0x3d21d1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movq 0x68(%r14), %rdi
callq 0x17e319
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5633e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_feature_node
static int spec_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                                     GtError *err)
{
  int had_err = 0;
  GtSpecVisitor *sv;
  GtSpecVisitorNodeTraverseInfo info;
  gt_error_check(err);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
testq %rdx, %rdx
je 0x17f56a
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17f602
callq 0x17f3cc
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
movq 0x8(%rsp), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x17ff17
movl %eax, %ebp
testl %eax, %eax
jne 0x17f5ea
movq 0x8(%rsp), %rdi
callq 0x149b8d
xorl %ebp, %ebp
testb %al, %al
je 0x17f5ea
leaq 0x10(%rsp), %r15
movq %r14, 0x8(%r15)
movq %rbx, (%r15)
movq 0x60(%r14), %rdi
leaq 0x8(%rsp), %r12
movl $0x8, %edx
movq %r12, %rsi
callq 0xd49ce
movq (%r12), %rdi
leaq 0xa08(%rip), %rdx       # 0x17ffd8
movq %r15, %rsi
movq %rbx, %rcx
callq 0x14aaf6
movl %eax, %ebp
movq 0x8(%r15), %rax
movq 0x60(%rax), %rdi
callq 0xd47f5
movq 0x68(%r14), %rdi
callq 0x17e319
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x56377
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_region_node
static int spec_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                    GtError *err)
{
  int had_err = 0;
  GtSpecVisitor *sv;
  gt_error_check(err);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x17f62d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17f6c9
callq 0x17f3cc
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
movl 0x34(%rax), %edx
xorl %ebp, %ebp
movl %edx, %eax
negl %eax
jo 0x17f6b5
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e852
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x14b5fc
movq %r12, %rdi
movq %rax, %rsi
callq 0x18f4ad
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f092
testl %eax, %eax
je 0x17f6b5
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
leaq 0x252b29(%rip), %rsi    # 0x3d21d1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movq 0x68(%r14), %rdi
callq 0x17e319
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x563b0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_sequence_node
static int spec_visitor_sequence_node(GtNodeVisitor *nv, GtSequenceNode *sn,
                                      GtError *err)
{
  int had_err = 0;
  GtSpecVisitor *sv;
  gt_error_check(err);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x17f6f4
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17f790
callq 0x17f3cc
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
movl 0x3c(%rax), %edx
xorl %ebp, %ebp
movl %edx, %eax
negl %eax
jo 0x17f77c
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e852
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x14b5fc
movq %r12, %rdi
movq %rax, %rsi
callq 0x18f4ad
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f092
testl %eax, %eax
je 0x17f77c
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
leaq 0x252a62(%rip), %rsi    # 0x3d21d1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movq 0x68(%r14), %rdi
callq 0x17e319
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x563e9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_meta_node
static int spec_visitor_meta_node(GtNodeVisitor *nv, GtMetaNode *mn,
                                  GtError *err)
{
  int had_err = 0;
  GtSpecVisitor *sv;
  gt_error_check(err);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rdx, %rdx
je 0x17f7bb
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17f857
callq 0x17f3cc
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
movl 0x30(%rax), %edx
xorl %ebp, %ebp
movl %edx, %eax
negl %eax
jo 0x17f843
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e852
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x14b5fc
movq %r12, %rdi
movq %rax, %rsi
callq 0x18f4ad
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f092
testl %eax, %eax
je 0x17f843
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
leaq 0x25299b(%rip), %rsi    # 0x3d21d1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movq 0x68(%r14), %rdi
callq 0x17e319
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x56422
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_luaL_opencustomlibs
static void spec_luaL_opencustomlibs(lua_State *L, const luaL_Reg *lib)
{
  for (; lib->func; lib++) {
    lua_pushcfunction(L, lib->func);
    lua_pushstring(L, lib->name);
    lua_call(L, 1, 0);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
je 0x17ff0f
movq %rdi, %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x22e48c
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x22e0c4
movq %r14, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0x22efe6
movq 0x18(%rbx), %rsi
addq $0x10, %rbx
testq %rsi, %rsi
jne 0x17fede
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_process_node
static int spec_visitor_process_node(GtSpecVisitor *sv, GtFeatureNode *node,
                                     GtError *err)
{
  int had_err = 0, *ref;
  const char *type;

  if (!gt_feature_node_is_pseudo(node)) {
    type = gt_feature_node_get_type(node);
    gt_assert(type);
    if ((ref = gt_hashmap_get(sv->type_specs, type))) {
      sv->current_node = (GtGenomeNode*) node;
      lua_rawgeti(sv->L, LUA_REGISTRYINDEX, *ref);
      gt_lua_genome_node_push(sv->L, gt_genome_node_ref((GtGenomeNode*) node));
      if (lua_pcall(sv->L, 1, 0, 0)) {
        const char *error = lua_tostring(sv->L, -1);
        gt_error_set(err, "%s", error);
        had_err = -1;
      }
    }
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x149d95
xorl %ebp, %ebp
testb %al, %al
jne 0x17ffc8
movq %r15, %rdi
callq 0x149bb2
testq %rax, %rax
je 0x17ffd3
movq 0x20(%r14), %rdi
movq %rax, %rsi
callq 0x105a11
testq %rax, %rax
je 0x17ffc8
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl (%rax), %edx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e852
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x14b5fc
movq %r12, %rdi
movq %rax, %rsi
callq 0x18f4ad
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f092
testl %eax, %eax
je 0x17ffc8
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
leaq 0x252216(%rip), %rsi    # 0x3d21d1
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1019cf
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x565ea
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_visitor_visit_child
static int spec_visitor_visit_child(GtFeatureNode* fn, void *nti, GtError *err)
{
  int had_err = 0;
  GtSpecVisitorNodeTraverseInfo* info = (GtSpecVisitorNodeTraverseInfo*) nti;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rsi
movq %rdi, (%rsp)
movq 0x8(%rbx), %rdi
callq 0x17ff17
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x180049
movq (%rsp), %rdi
callq 0x149b8d
xorl %ebp, %ebp
testb %al, %al
je 0x180049
movq 0x8(%rbx), %rax
movq 0x60(%rax), %rdi
movq %rsp, %r15
movl $0x8, %edx
movq %r15, %rsi
callq 0xd49ce
movq (%r15), %rdi
leaq -0x57(%rip), %rdx       # 0x17ffd8
movq %rbx, %rsi
movq %r14, %rcx
callq 0x14aaf6
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x60(%rax), %rdi
callq 0xd47f5
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_feature_node_lua_appears_as_root_node
static int spec_feature_node_lua_appears_as_root_node(lua_State *L)
{
  GtGenomeNode **gn;
  GtFeatureNode *fn;
  GtSpecVisitor *sv;
  bool result = false;
  gn = check_genome_node(L, 1);
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");

  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);

  gt_assert(sv && sv->graph_context);
  result = (gt_array_size(sv->graph_context) == 0);
  lua_pushboolean(L, result);

  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x21ce15(%rip), %rdx    # 0x39ce87
movl $0x1, %esi
callq 0x230dae
movq (%rax), %rdi
callq 0x14aefc
testq %rax, %rax
jne 0x18009d
leaq 0x21ce87(%rip), %rdx    # 0x39cf17
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230a08
leaq 0x345154(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
testq %rax, %rax
je 0x1800f1
movq 0x60(%rax), %rdi
testq %rdi, %rdi
je 0x1800f1
callq 0xd4a9a
xorl %esi, %esi
testq %rax, %rax
sete %sil
movq %rbx, %rdi
callq 0x22e570
movl $0x1, %eax
popq %rbx
retq
callq 0x56621
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_feature_node_get_path
static int spec_feature_node_get_path(lua_State *L)
{
  GtGenomeNode **gn;
  GtFeatureNode *fn;
  GtSpecVisitor *sv;
  GtUword i, j = 0;
  gn = check_genome_node(L, 1);
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");

  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);
  lua_newtable(L);

  gt_assert(sv && sv->graph_context);
  if (gt_array_size(sv->graph_context) > 0) {
    for (i = gt_array_size(sv->graph_context) - 1; i + 1 > 0; i--) {
      GtFeatureNode* fn2
        = *(GtFeatureNode**) gt_array_get(sv->graph_context, i);
      lua_pushinteger(L, j + 1); /* in Lua we index from 1 on */
      gt_lua_genome_node_push(L, gt_genome_node_ref((GtGenomeNode*) fn2));
      lua_rawset(L, -3);
      j++;
    }
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x21cbd5(%rip), %rdx    # 0x39ce87
movl $0x1, %esi
callq 0x230dae
movq (%rax), %rdi
callq 0x14aefc
testq %rax, %rax
jne 0x1802dd
leaq 0x21cc47(%rip), %rdx    # 0x39cf17
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230a08
leaq 0x344f14(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22e8fc
testq %r14, %r14
je 0x180399
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x180399
callq 0xd4a9a
testq %rax, %rax
je 0x18038a
movq 0x60(%r14), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x18038a
movq %rax, %r15
decq %r15
movl $0x1, %r12d
movq 0x60(%r14), %rdi
movq %r15, %rsi
callq 0xd47ba
movq (%rax), %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22ded3
movq %r13, %rdi
callq 0x14b5fc
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18f4ad
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x22ecef
incq %r12
addq $-0x1, %r15
jb 0x180347
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x56693
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_is_a
static int spec_is_a(lua_State *L)
{
  GtSpecVisitor *sv;
  const char *child, *parent;
  bool result = false;
  child = gt_symbol(luaL_checkstring(L, 1));
  parent = gt_symbol(luaL_checkstring(L, 2));

  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);
  gt_assert(sv);

  if (!sv->type_checker) {
    luaL_where(L, 1);
    lua_pushstring(L, "'string.is_a()' requires a type "
                      "checker (-typecheck)");
    lua_concat(L, 2);
    return lua_error(L);
  }

  if (sv->type_checker) {
    luaL_argcheck(L, gt_type_checker_is_valid(sv->type_checker, child),
                  1, "not a valid SO type");
    luaL_argcheck(L, gt_type_checker_is_valid(sv->type_checker, parent),
                  2, "not a valid SO type");
    result = gt_type_checker_is_a(sv->type_checker, parent, child);
  } else {
    result = (child == parent);
  }
  lua_pushboolean(L, result);

  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %rdi
callq 0x12234f
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %rdi
callq 0x12234f
movq %rax, %r15
leaq 0x344e17(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
testq %rax, %rax
je 0x1804c5
movq %rax, %r12
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x180489
movq %r14, %rsi
callq 0x18b801
testb %al, %al
jne 0x180438
leaq 0x21cb53(%rip), %rdx    # 0x39cf7e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230a08
movq 0x28(%r12), %rdi
movq %r15, %rsi
callq 0x18b801
testb %al, %al
jne 0x18045d
leaq 0x21cb2e(%rip), %rdx    # 0x39cf7e
movq %rbx, %rdi
movl $0x2, %esi
callq 0x230a08
movq 0x28(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x18b865
movzbl %al, %esi
movq %rbx, %rdi
callq 0x22e570
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230bcc
leaq 0x21cc0c(%rip), %rsi    # 0x39d0a9
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22f73e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22f4f8
callq 0x566cc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_part_of
static int spec_part_of(lua_State *L)
{
  GtSpecVisitor *sv;
  const char *child, *parent;
  bool result = false;
  child = gt_symbol(luaL_checkstring(L, 1));
  parent = gt_symbol(luaL_checkstring(L, 2));

  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);
  gt_assert(sv);

  if (!sv->type_checker) {
    luaL_where(L, 1);
    lua_pushstring(L, "'string.part_of()' requires a type "
                      "checker (-typecheck)");
    lua_concat(L, 2);
    return lua_error(L);
  }

  luaL_argcheck(L, gt_type_checker_is_valid(sv->type_checker, child),
                1, "not a valid SO type");
  luaL_argcheck(L, gt_type_checker_is_valid(sv->type_checker, parent),
                2, "not a valid SO type");
  result = gt_type_checker_is_partof(sv->type_checker, parent, child);
  lua_pushboolean(L, result);

  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %rdi
callq 0x12234f
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x230d0f
movq %rax, %rdi
callq 0x12234f
movq %rax, %r15
leaq 0x344ceb(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
testq %rax, %rax
je 0x1805f1
movq %rax, %r12
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x1805b5
movq %r14, %rsi
callq 0x18b801
testb %al, %al
jne 0x180564
leaq 0x21ca27(%rip), %rdx    # 0x39cf7e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230a08
movq 0x28(%r12), %rdi
movq %r15, %rsi
callq 0x18b801
testb %al, %al
jne 0x180589
leaq 0x21ca02(%rip), %rdx    # 0x39cf7e
movq %rbx, %rdi
movl $0x2, %esi
callq 0x230a08
movq 0x28(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x18b847
movzbl %al, %esi
movq %rbx, %rdi
callq 0x22e570
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230bcc
leaq 0x21cb22(%rip), %rsi    # 0x39d0eb
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22f73e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x22f4f8
callq 0x56705
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_register_feature_callback
static int spec_register_feature_callback(lua_State *L)
{
  int ref, *refptr;
  const char *type;
  GtSpecVisitor *sv;

  /* get parameters from stack */
  ref = luaL_ref(L, LUA_REGISTRYINDEX);
  type = lua_tostring(L, -1);
  gt_log_log("registering feature specs for type %s at ref %d", type, ref);
  /* get visitor from registry */
  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);
  /* register Lua callback for type */
  if (!gt_hashmap_get(sv->type_specs, type)) {
    refptr = gt_malloc(sizeof (int));
    *refptr = ref;
    gt_hashmap_add(sv->type_specs, gt_cstr_dup(type), refptr);
  } else {
    luaL_where(L, 1);
    lua_pushstring(L, "duplicate definition of spec for feature type '");
    lua_pushstring(L, type);
    lua_pushstring(L, "'");
    lua_concat(L, 4);
    return lua_error(L);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2316f5
movl %eax, %ebp
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
movq %rax, %r14
leaq 0x21cafe(%rip), %rdi    # 0x39d123
movq %rax, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x108e02
leaq 0x344bc0(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
movq %rax, %r15
movq 0x20(%rax), %rdi
movq %r14, %rsi
callq 0x105a11
testq %rax, %rax
je 0x1806c3
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230bcc
leaq 0x21cad1(%rip), %rsi    # 0x39d153
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22e0c4
leaq 0x1fb920(%rip), %rsi    # 0x37bfbc
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movl $0x4, %esi
callq 0x22f73e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22f4f8
leaq 0x21c629(%rip), %rsi    # 0x39ccf3
movl $0x4, %edi
movl $0x13d, %edx            # imm = 0x13D
callq 0x1092b2
movq %rax, %rbx
movl %ebp, (%rax)
movq 0x20(%r15), %r15
movq %r14, %rdi
callq 0xe8760
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x105a4c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_register_region_callback
static int spec_register_region_callback(lua_State *L)
{
  int ref;
  GtSpecVisitor *sv;

  /* get parameters from stack */
  ref = luaL_ref(L, LUA_REGISTRYINDEX);
  /* get visitor from registry */
  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);
  /* register Lua callback */
  if (sv->region_ref == GT_UNDEF_INT) {
    sv->region_ref = ref;
    gt_log_log("registering region specs at ref %d", ref);
    gt_assert(sv->region_ref != GT_UNDEF_INT);
  } else {
    luaL_where(L, 1);
    lua_pushstring(L, "duplicate definition of spec for region nodes");
    lua_concat(L, 2);
    return lua_error(L);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2316f5
movl %eax, %ebp
leaq 0x344ad6(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
xorl %r15d, %r15d
cmpl 0x34(%rax), %r15d
jno 0x180776
movq %rax, %r14
movl %ebp, 0x34(%rax)
leaq 0x21ca29(%rip), %rdi    # 0x39d183
movl %ebp, %esi
xorl %eax, %eax
callq 0x108e02
cmpl 0x34(%r14), %r15d
jo 0x1807b1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230bcc
leaq 0x21ca59(%rip), %rsi    # 0x39d1e3
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22f73e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22f4f8
callq 0x5673e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_register_meta_callback
static int spec_register_meta_callback(lua_State *L)
{
  int ref;
  GtSpecVisitor *sv;

  /* get parameters from stack */
  ref = luaL_ref(L, LUA_REGISTRYINDEX);
  /* get visitor from registry */
  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);
  /* register Lua callback */
  if (sv->meta_ref == GT_UNDEF_INT) {
    sv->meta_ref = ref;
    gt_log_log("registering meta specs at ref %d", ref);
    gt_assert(sv->meta_ref != GT_UNDEF_INT);
  } else {
    luaL_where(L, 1);
    lua_pushstring(L, "duplicate definition of spec for meta nodes");
    lua_concat(L, 2);
    return lua_error(L);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2316f5
movl %eax, %ebp
leaq 0x344a25(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
xorl %r15d, %r15d
cmpl 0x30(%rax), %r15d
jno 0x180827
movq %rax, %r14
movl %ebp, 0x30(%rax)
leaq 0x21ca06(%rip), %rdi    # 0x39d211
movl %ebp, %esi
xorl %eax, %eax
callq 0x108e02
cmpl 0x30(%r14), %r15d
jo 0x180862
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230bcc
leaq 0x21ca30(%rip), %rsi    # 0x39d26b
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22f73e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22f4f8
callq 0x56777
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_register_comment_callback
static int spec_register_comment_callback(lua_State *L)
{
  int ref;
  GtSpecVisitor *sv;

  /* get parameters from stack */
  ref = luaL_ref(L, LUA_REGISTRYINDEX);
  /* get visitor from registry */
  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);
  /* register Lua callback */
  if (sv->comment_ref == GT_UNDEF_INT) {
    sv->comment_ref = ref;
    gt_log_log("registering comment specs at ref %d", ref);
    gt_assert(sv->comment_ref != GT_UNDEF_INT);
  } else {
    luaL_where(L, 1);
    lua_pushstring(L, "duplicate definition of spec for comment nodes");
    lua_concat(L, 2);
    return lua_error(L);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2316f5
movl %eax, %ebp
leaq 0x344974(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
xorl %r15d, %r15d
cmpl 0x38(%rax), %r15d
jno 0x1808d8
movq %rax, %r14
movl %ebp, 0x38(%rax)
leaq 0x21c9db(%rip), %rdi    # 0x39d297
movl %ebp, %esi
xorl %eax, %eax
callq 0x108e02
cmpl 0x38(%r14), %r15d
jo 0x180913
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230bcc
leaq 0x21ca0e(%rip), %rsi    # 0x39d2fa
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22f73e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22f4f8
callq 0x567b0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_register_sequence_callback
static int spec_register_sequence_callback(lua_State *L)
{
  int ref;
  GtSpecVisitor *sv;

  /* get parameters from stack */
  ref = luaL_ref(L, LUA_REGISTRYINDEX);
  /* get visitor from registry */
  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);
  /* register Lua callback */
  if (sv->sequence_ref == GT_UNDEF_INT) {
    sv->sequence_ref = ref;
    gt_log_log("registering sequence specs at ref %d", ref);
    gt_assert(sv->sequence_ref != GT_UNDEF_INT);
  } else {
    luaL_where(L, 1);
    lua_pushstring(L, "duplicate definition of spec for sequence nodes");
    lua_concat(L, 2);
    return lua_error(L);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2316f5
movl %eax, %ebp
leaq 0x3448c3(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
xorl %r15d, %r15d
cmpl 0x3c(%rax), %r15d
jno 0x180989
movq %rax, %r14
movl %ebp, 0x3c(%rax)
leaq 0x21c9bc(%rip), %rdi    # 0x39d329
movl %ebp, %esi
xorl %eax, %eax
callq 0x108e02
cmpl 0x3c(%r14), %r15d
jo 0x1809c4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230bcc
leaq 0x21c9f2(%rip), %rsi    # 0x39d38f
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22f73e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22f4f8
callq 0x567e9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_it
static int spec_it(lua_State *L)
{
  const char *name;
  GtSpecVisitor *sv;

  /* get parameters from stack */
  name = lua_tostring(L, -2);

  /* get visitor from registry */
  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);
  lua_pop(L, 1);

  /* handle aspect */
  sv->current_aspect = name;

  if (lua_pcall(L, 0, 0, 0)) {
    if (sv->runtime_fail_hard) {
      return lua_error(L);
    } else {
      const char *error = lua_tostring(sv->L, -1);
      gt_spec_results_add_result(sv->res, sv->current_aspect, sv->current_node,
                                 GT_SPEC_RUNTIME_ERROR, error);
    }
  }

  sv->current_aspect = NULL;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
xorl %edx, %edx
callq 0x22db9e
movq %rax, %r15
leaq 0x344811(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
movq %rax, %r14
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22d42e
movq %r15, 0x50(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22f092
testl %eax, %eax
je 0x180a6c
cmpb $0x1, 0x70(%r14)
jne 0x180a43
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x22f4f8
movq 0x10(%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x22db9e
movq 0x68(%r14), %rdi
movq 0x48(%r14), %rdx
movq 0x50(%r14), %rsi
movl $0x2, %ecx
movq %rax, %r8
callq 0x17e342
movq $0x0, 0x50(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_expect
static int spec_expect(lua_State *L)
{
  int ref;
  GtSpecVisitor *sv;

  /* accept only one parameter */
  if (lua_gettop(L) > 1) {
    luaL_where(L, 1);
    lua_pushstring(L, "'expect' takes only one parameter");
    lua_concat(L, 2);
    return lua_error(L);
  }

  /* get parameters from stack */
  ref = luaL_ref(L, LUA_REGISTRYINDEX);

  /* get visitor */
  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);

  /* check for lone expect() calls -- currently disallowed */
  if (!sv->current_aspect) {
    luaL_where(L, 1);
    lua_pushstring(L, "'expect' must be called inside an aspect "
                      "definition ('it')");
    lua_concat(L, 2);
    return lua_error(L);
  }

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

  /* return new object with __index metamethod set */
  lua_newtable(L);
  luaL_getmetatable(L, "GenomeTools.specexpect");
  lua_setmetatable(L, -2);

  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x22d421
movq %rbx, %rdi
cmpl $0x2, %eax
jl 0x180aa5
movl $0x1, %esi
callq 0x230bcc
leaq 0x21c91f(%rip), %rsi    # 0x39d3bf
jmp 0x180b31
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2316f5
movl %eax, %ebp
leaq 0x344740(%rip), %rsi    # 0x4c51f8
movq %rbx, %rdi
callq 0x22e58a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e5c2
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x22de0e
cmpq $0x0, 0x50(%rax)
je 0x180b1d
movl %ebp, 0x40(%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22e8fc
leaq 0x21c3e8(%rip), %rdx    # 0x39cedf
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x22e6f4
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x22ee93
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x230bcc
leaq 0x21c8b0(%rip), %rsi    # 0x39d3e1
movq %rbx, %rdi
callq 0x22e0c4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x22f73e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22f4f8