LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x177262
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1772fe
callq 0x176f38
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
movl 0x3c(%rax), %edx
xorl %ebp, %ebp
movl %edx, %eax
negl %eax
jo 0x1772ea
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224b36
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x1443a0
movq %r12, %rdi
movq %rax, %rsi
callq 0x186e7d
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22537b
testl %eax, %eax
je 0x1772ea
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
leaq 0x2517cc(%rip), %rsi    # 0x3c8aa9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movq 0x68(%r14), %rdi
callq 0x175ea5
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5528b
// File: /workspace/github_c_makefile_star2_O3/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 0x177329
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1773c5
callq 0x176f38
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
movl 0x30(%rax), %edx
xorl %ebp, %ebp
movl %edx, %eax
negl %eax
jo 0x1773b1
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224b36
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x1443a0
movq %r12, %rdi
movq %rax, %rsi
callq 0x186e7d
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22537b
testl %eax, %eax
je 0x1773b1
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
leaq 0x251705(%rip), %rsi    # 0x3c8aa9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movq 0x68(%r14), %rdi
callq 0x175ea5
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x552c4
// File: /workspace/github_c_makefile_star2_O3/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 0x142b68
xorl %ebp, %ebp
testb %al, %al
jne 0x177b12
movq %r15, %rdi
callq 0x142988
testq %rax, %rax
je 0x177b1d
movq 0x20(%r14), %rdi
movq %rax, %rsi
callq 0x100add
testq %rax, %rax
je 0x177b12
movq %r15, 0x48(%r14)
movq 0x10(%r14), %rdi
movl (%rax), %edx
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224b36
movq 0x10(%r14), %r12
movq %r15, %rdi
callq 0x1443a0
movq %r12, %rdi
movq %rax, %rsi
callq 0x186e7d
movq 0x10(%r14), %rdi
xorl %ebp, %ebp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22537b
testl %eax, %eax
je 0x177b12
movq 0x10(%r14), %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
leaq 0x250fa4(%rip), %rsi    # 0x3c8aa9
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x55453
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movq %rdi, (%rsp)
movq 0x8(%rsi), %rdi
movq %r15, %rsi
callq 0x177a61
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x177b95
movq %r15, %rdi
callq 0x142963
xorl %ebp, %ebp
testb %al, %al
je 0x177b95
movq 0x8(%rbx), %rax
movq 0x60(%rax), %rdi
movq %rsp, %r15
movl $0x8, %edx
movq %r15, %rsi
callq 0xd2410
movq (%r15), %rdi
leaq -0x59(%rip), %rdx       # 0x177b22
movq %rbx, %rsi
movq %r14, %rcx
callq 0x1438a5
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x60(%rax), %rdi
callq 0xd2242
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x21be3b(%rip), %rdx    # 0x3939f9
movl $0x1, %esi
callq 0x22712c
movq (%rax), %rdi
callq 0x143cab
testq %rax, %rax
jne 0x177be9
leaq 0x21bead(%rip), %rdx    # 0x393a89
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226d91
leaq 0x342608(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
testq %rax, %rax
je 0x177c3d
movq 0x60(%rax), %rdi
testq %rdi, %rdi
je 0x177c3d
callq 0xd24e0
xorl %esi, %esi
testq %rax, %rax
sete %sil
movq %rbx, %rdi
callq 0x2248a3
movl $0x1, %eax
popq %rbx
retq
callq 0x5548a
// File: /workspace/github_c_makefile_star2_O3/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 0x21bc0f(%rip), %rdx    # 0x3939f9
movl $0x1, %esi
callq 0x22712c
movq (%rax), %rdi
callq 0x143cab
testq %rax, %rax
jne 0x177e15
leaq 0x21bc81(%rip), %rdx    # 0x393a89
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226d91
leaq 0x3423dc(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x224be0
testq %r14, %r14
je 0x177ed1
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x177ed1
callq 0xd24e0
testq %rax, %rax
je 0x177ec2
movq 0x60(%r14), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x177ec2
movq %rax, %r15
decq %r15
movl $0x1, %r12d
movq 0x60(%r14), %rdi
movq %r15, %rsi
callq 0xd2207
movq (%rax), %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2241dd
movq %r13, %rdi
callq 0x1443a0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x186e7d
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x224fd4
incq %r12
addq $-0x1, %r15
jb 0x177e7f
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x554fc
// File: /workspace/github_c_makefile_star2_O3/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 0x22708d
movq %rax, %rdi
callq 0x11c5ff
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x22708d
movq %rax, %rdi
callq 0x11c5ff
movq %rax, %r15
leaq 0x3422df(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
testq %rax, %rax
je 0x177ffd
movq %rax, %r12
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x177fc1
movq %r14, %rsi
callq 0x1830f1
testb %al, %al
jne 0x177f70
leaq 0x21bb8d(%rip), %rdx    # 0x393af0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226d91
movq 0x28(%r12), %rdi
movq %r15, %rsi
callq 0x1830f1
testb %al, %al
jne 0x177f95
leaq 0x21bb68(%rip), %rdx    # 0x393af0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x226d91
movq 0x28(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x183155
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2248a3
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226f4a
leaq 0x21bc46(%rip), %rsi    # 0x393c1b
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movl $0x2, %esi
callq 0x225a4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x225800
callq 0x55535
// File: /workspace/github_c_makefile_star2_O3/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 0x22708d
movq %rax, %rdi
callq 0x11c5ff
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x22708d
movq %rax, %rdi
callq 0x11c5ff
movq %rax, %r15
leaq 0x3421b3(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
testq %rax, %rax
je 0x178129
movq %rax, %r12
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x1780ed
movq %r14, %rsi
callq 0x1830f1
testb %al, %al
jne 0x17809c
leaq 0x21ba61(%rip), %rdx    # 0x393af0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226d91
movq 0x28(%r12), %rdi
movq %r15, %rsi
callq 0x1830f1
testb %al, %al
jne 0x1780c1
leaq 0x21ba3c(%rip), %rdx    # 0x393af0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x226d91
movq 0x28(%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x183137
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2248a3
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226f4a
leaq 0x21bb5c(%rip), %rsi    # 0x393c5d
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movl $0x2, %esi
callq 0x225a4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x225800
callq 0x5556e
// File: /workspace/github_c_makefile_star2_O3/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 0x227b8f
movl %eax, %ebp
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
movq %rax, %r14
leaq 0x21bb38(%rip), %rdi    # 0x393c95
movq %rax, %rsi
movl %ebp, %edx
xorl %eax, %eax
callq 0x103d72
leaq 0x342088(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
movq %rax, %r15
movq 0x20(%rax), %rdi
movq %r14, %rsi
callq 0x100add
testq %rax, %rax
je 0x1781fb
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226f4a
leaq 0x21bb0b(%rip), %rsi    # 0x393cc5
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2243ba
leaq 0x1fab68(%rip), %rsi    # 0x372d3c
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movl $0x4, %esi
callq 0x225a4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x225800
leaq 0x21b675(%rip), %rsi    # 0x393877
movl $0x4, %edi
movl $0x13d, %edx            # imm = 0x13D
callq 0x104226
movq %rax, %rbx
movl %ebp, (%rax)
movq 0x20(%r15), %r15
movq %r14, %rdi
callq 0xe4290
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x100b18
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x227b8f
movl %eax, %ebp
leaq 0x341f9e(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
xorl %r15d, %r15d
cmpl 0x34(%rax), %r15d
jno 0x1782ae
movq %rax, %r14
movl %ebp, 0x34(%rax)
leaq 0x21ba63(%rip), %rdi    # 0x393cf5
movl %ebp, %esi
xorl %eax, %eax
callq 0x103d72
cmpl 0x34(%r14), %r15d
jo 0x1782e9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226f4a
leaq 0x21ba93(%rip), %rsi    # 0x393d55
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movl $0x2, %esi
callq 0x225a4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x225800
callq 0x555a7
// File: /workspace/github_c_makefile_star2_O3/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 0x227b8f
movl %eax, %ebp
leaq 0x341eed(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
xorl %r15d, %r15d
cmpl 0x30(%rax), %r15d
jno 0x17835f
movq %rax, %r14
movl %ebp, 0x30(%rax)
leaq 0x21ba40(%rip), %rdi    # 0x393d83
movl %ebp, %esi
xorl %eax, %eax
callq 0x103d72
cmpl 0x30(%r14), %r15d
jo 0x17839a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226f4a
leaq 0x21ba6a(%rip), %rsi    # 0x393ddd
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movl $0x2, %esi
callq 0x225a4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x225800
callq 0x555e0
// File: /workspace/github_c_makefile_star2_O3/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 0x227b8f
movl %eax, %ebp
leaq 0x341e3c(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
xorl %r15d, %r15d
cmpl 0x38(%rax), %r15d
jno 0x178410
movq %rax, %r14
movl %ebp, 0x38(%rax)
leaq 0x21ba15(%rip), %rdi    # 0x393e09
movl %ebp, %esi
xorl %eax, %eax
callq 0x103d72
cmpl 0x38(%r14), %r15d
jo 0x17844b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226f4a
leaq 0x21ba48(%rip), %rsi    # 0x393e6c
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movl $0x2, %esi
callq 0x225a4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x225800
callq 0x55619
// File: /workspace/github_c_makefile_star2_O3/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 0x227b8f
movl %eax, %ebp
leaq 0x341d8b(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
xorl %r15d, %r15d
cmpl 0x3c(%rax), %r15d
jno 0x1784c1
movq %rax, %r14
movl %ebp, 0x3c(%rax)
leaq 0x21b9f6(%rip), %rdi    # 0x393e9b
movl %ebp, %esi
xorl %eax, %eax
callq 0x103d72
cmpl 0x3c(%r14), %r15d
jo 0x1784fc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226f4a
leaq 0x21ba2c(%rip), %rsi    # 0x393f01
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movl $0x2, %esi
callq 0x225a4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x225800
callq 0x55652
// File: /workspace/github_c_makefile_star2_O3/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 0x223ea8
movq %rax, %r15
leaq 0x341cd9(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
movq %rax, %r14
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x2235b9
movq %r15, 0x50(%r14)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x22537b
testl %eax, %eax
je 0x1785a4
cmpb $0x1, 0x70(%r14)
jne 0x17857b
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x225800
movq 0x10(%r14), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x223ea8
movq 0x68(%r14), %rdi
movq 0x48(%r14), %rdx
movq 0x50(%r14), %rsi
movl $0x2, %ecx
movq %rax, %r8
callq 0x175ece
movq $0x0, 0x50(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2235ac
movq %rbx, %rdi
cmpl $0x2, %eax
jl 0x1785dd
movl $0x1, %esi
callq 0x226f4a
leaq 0x21b959(%rip), %rsi    # 0x393f31
jmp 0x178669
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x227b8f
movl %eax, %ebp
leaq 0x341c08(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
cmpq $0x0, 0x50(%rax)
je 0x178655
movl %ebp, 0x40(%rax)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x224be0
leaq 0x21b422(%rip), %rdx    # 0x393a51
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x224a06
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x225186
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
movl $0x1, %esi
callq 0x226f4a
leaq 0x21b8ea(%rip), %rsi    # 0x393f53
movq %rbx, %rdi
callq 0x2243ba
movq %rbx, %rdi
movl $0x2, %esi
callq 0x225a4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x225800
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/spec_visitor.c
// Function: spec_expect_index
static int spec_expect_index(lua_State *L)
{
  const char *matcher_name;
  GtSpecVisitor *sv;

  /* get parameters from stack */
  matcher_name = lua_tostring(L, 2);
  lua_pushlightuserdata(L, (void *) &spec_defuserdata);
  lua_gettable(L, LUA_REGISTRYINDEX);
  sv = lua_touserdata(L, -1);

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

  /* return dispatcher function */
  lua_pushcfunction(L, spec_expect_matchdispatch);

  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, %esi
xorl %edx, %edx
callq 0x223ea8
movq %rax, %r14
leaq 0x341b4f(%rip), %rsi    # 0x4ba1f8
movq %rbx, %rdi
callq 0x2248bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x2248f5
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x224118
movq %r14, 0x58(%rax)
leaq 0x1dd(%rip), %rsi       # 0x1788b3
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2247b8
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_class
const GtNodeStreamClass* gt_splice_site_info_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSpliceSiteInfoStream),
                                   gt_splice_site_info_stream_free,
                                   gt_splice_site_info_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x345dda(%rip)    # 0x4be8b0
jne 0x178af7
leaq 0x26(%rip), %rsi        # 0x178b05
leaq 0x49(%rip), %rdx        # 0x178b2f
movl $0x20, %edi
callq 0x162d34
movq %rax, 0x345db9(%rip)    # 0x4be8b0
callq 0xe2545
movq 0x345dad(%rip), %rax    # 0x4be8b0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_next
static int gt_splice_site_info_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                           GtError *err)
{
  GtSpliceSiteInfoStream *ssis;
  int had_err;
  gt_error_check(err);
  ssis = gt_splice_site_info_stream_cast(ns);
  had_err = gt_node_stream_next(ssis->in_stream, gn, err);
  if (!had_err) {
    gt_assert(ssis->splice_site_info_visitor);
    if (*gn) {
      had_err = gt_genome_node_accept(*gn, ssis->splice_site_info_visitor, err);
      if (had_err) {
        /* we own the node -> delete it */
        gt_genome_node_delete(*gn);
        *gn = NULL;
      }
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x178b50
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x178bbb
callq 0x178ac8
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
movq %rax, %r15
movq 0x10(%rax), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x162e68
movl %eax, %ebp
testl %eax, %eax
je 0x178b85
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r15), %rsi
testq %rsi, %rsi
je 0x178bc0
movq (%rbx), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x178b78
movq %r14, %rdx
callq 0x14472c
testl %eax, %eax
je 0x178b78
movl %eax, %r14d
movq (%rbx), %rdi
callq 0x1451a0
movq $0x0, (%rbx)
movl %r14d, %ebp
jmp 0x178b78
callq 0x556fd
callq 0x55734
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_new
GtNodeStream* gt_splice_site_info_stream_new(GtNodeStream *in_stream,
                                             GtRegionMapping *rm)
{
  GtNodeStream *ns = gt_node_stream_create(gt_splice_site_info_stream_class(),
                                           false);
  GtSpliceSiteInfoStream *ssis = gt_splice_site_info_stream_cast(ns);
  ssis->in_stream = gt_node_stream_ref(in_stream);
  ssis->splice_site_info_visitor = gt_splice_site_info_visitor_new(rm);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x178ac8
movq %rax, %rdi
xorl %esi, %esi
callq 0x162d6c
movq %rax, %r15
callq 0x178ac8
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
movq %rax, %r12
movq %r14, %rdi
callq 0x162dd8
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x178fad
movq %rax, 0x18(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_show
bool gt_splice_site_info_stream_show(GtNodeStream *ns, GtFile *outfp)
{
  GtSpliceSiteInfoStream *ssis;
  gt_assert(ns);
  ssis = gt_splice_site_info_stream_cast(ns);
  return gt_splice_site_info_visitor_show(ssis->splice_site_info_visitor,
                                          outfp);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x178c53
movq %rsi, %rbx
movq %rdi, %r14
callq 0x178ac8
movq %rax, %rdi
movq %r14, %rsi
callq 0x162ff7
movq 0x18(%rax), %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17900a
callq 0x5576b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_intron_processed
bool gt_splice_site_info_stream_intron_processed(GtNodeStream *ns)
{
  GtSpliceSiteInfoStream *ssis;
  gt_assert(ns);
  ssis = gt_splice_site_info_stream_cast(ns);
  return gt_splice_site_info_visitor_intron_processed(ssis
                                                    ->splice_site_info_visitor);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x178c7b
movq %rdi, %rbx
callq 0x178ac8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq 0x18(%rax), %rdi
popq %rbx
jmp 0x17918b
callq 0x557a2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_stream.c
// Function: gt_splice_site_info_stream_show_canonical
bool gt_splice_site_info_stream_show_canonical(GtNodeStream *ns, bool show_gc)
{
  GtSpliceSiteInfoStream *ssis;
  gt_assert(ns);
  ssis = gt_splice_site_info_stream_cast(ns);
  return gt_splice_site_info_visitor_show_canonical(ssis
                                                    ->splice_site_info_visitor,
                                                    show_gc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x178cb1
movl %esi, %ebx
movq %rdi, %r14
callq 0x178ac8
movq %rax, %rdi
movq %r14, %rsi
callq 0x162ff7
movq 0x18(%rax), %rdi
movzbl %bl, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1791ae
callq 0x557d9
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_class
const GtNodeVisitorClass* gt_splice_site_info_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
   nvc = gt_node_visitor_class_new(sizeof (GtSpliceSiteInfoVisitor),
                                   splice_site_info_visitor_free,
                                   NULL,
                                   splice_site_info_visitor_feature_node,
                                   NULL,
                                   NULL,
                                   NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x345bf2(%rip)    # 0x4be8b8
jne 0x178cf7
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x178d05
leaq 0x6d(%rip), %rcx        # 0x178d4b
movl $0x38, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x345bc1(%rip)    # 0x4be8b8
callq 0xe2545
movq 0x345bb5(%rip), %rax    # 0x4be8b8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: splice_site_info_visitor_free
static void splice_site_info_visitor_free(GtNodeVisitor *nv)
{
  GtSpliceSiteInfoVisitor *splice_site_info_visitor;
  gt_assert(nv);
  splice_site_info_visitor = splice_site_info_visitor_cast(nv);
  gt_region_mapping_delete(splice_site_info_visitor->region_mapping);
  gt_string_distri_delete(splice_site_info_visitor->splicesites);
  gt_string_distri_delete(splice_site_info_visitor->donorsites);
  gt_string_distri_delete(splice_site_info_visitor->acceptorsites);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x178d46
movq %rdi, %rbx
callq 0x178cb8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x16d652
movq 0x18(%rbx), %rdi
callq 0x11c57d
movq 0x20(%rbx), %rdi
callq 0x11c57d
movq 0x28(%rbx), %rdi
popq %rbx
jmp 0x11c57d
callq 0x55810
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_new
GtNodeVisitor* gt_splice_site_info_visitor_new(GtRegionMapping *rm)
{
  GtNodeVisitor *nv;
  GtSpliceSiteInfoVisitor *ssiv;
  gt_assert(rm);
  nv = gt_node_visitor_create(gt_splice_site_info_visitor_class());
  ssiv = splice_site_info_visitor_cast(nv);
  ssiv->region_mapping = rm;
  ssiv->splicesites = gt_string_distri_new();
  ssiv->acceptorsites = gt_string_distri_new();
  ssiv->donorsites = gt_string_distri_new();
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x179005
movq %rdi, %rbx
callq 0x178cb8
movq %rax, %rdi
callq 0x163080
movq %rax, %r14
callq 0x178cb8
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r15
movq %rbx, 0x10(%rax)
callq 0x11c288
movq %rax, 0x18(%r15)
callq 0x11c288
movq %rax, 0x28(%r15)
callq 0x11c288
movq %rax, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x55923
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_show
bool gt_splice_site_info_visitor_show(GtNodeVisitor *nv, GtFile *outfp)
{
  GtSpliceSiteInfoVisitor *ssiv;
  gt_assert(nv);
  ssiv = splice_site_info_visitor_cast(nv);

  if (ssiv->show) {
    /* show splice sites */
    gt_file_xprintf(outfp, "splice site distribution (for introns >= 4bp)\n");
    gt_string_distri_foreach(ssiv->splicesites, showsplicesite, outfp);
    gt_xputchar('\n');

    /* show donor sites */
    gt_file_xprintf(outfp, "donor site distribution (for introns >= 4bp)\n");
    gt_string_distri_foreach(ssiv->donorsites, showsinglesite, outfp);
    gt_xputchar('\n');

    /* show acceptor sites */
    gt_file_xprintf(outfp, "acceptor site distribution (for introns >= 4bp)\n");
    gt_string_distri_foreach(ssiv->acceptorsites, showsinglesite, outfp);
  }
  return ssiv->intron_processed;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1790c0
movq %rsi, %rbx
movq %rdi, %r14
callq 0x178cb8
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r14
cmpb $0x1, 0x30(%rax)
jne 0x1790b6
leaq 0x21b0e6(%rip), %rsi    # 0x394124
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfee51
movq 0x18(%r14), %rdi
leaq 0x72(%rip), %rsi        # 0x1790c5
movq %rbx, %rdx
callq 0x11c48c
movl $0xa, %edi
callq 0x11f92c
leaq 0x21b0e7(%rip), %rsi    # 0x394153
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfee51
movq 0x20(%r14), %rdi
leaq 0xbe(%rip), %r15        # 0x17913f
movq %r15, %rsi
movq %rbx, %rdx
callq 0x11c48c
movl $0xa, %edi
callq 0x11f92c
leaq 0x21b0e4(%rip), %rsi    # 0x394181
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfee51
movq 0x28(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x11c48c
movb 0x31(%r14), %al
popq %rbx
popq %r14
popq %r15
retq
callq 0x5595c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: showsplicesite
static void showsplicesite(const char *string, GtUword occurrences,
                           double probability, GT_UNUSED void *unused)
{
  gt_assert(string && strlen(string) == 4);
  gt_xputchar(string[0]);
  gt_xputchar(string[1]);
  gt_xputchar('-');
  gt_xputchar(string[2]);
  gt_xputchar(string[3]);
  printf(": %6.2f%% (n="GT_WU")\n", probability * 100.0, occurrences);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
testq %rdi, %rdi
je 0x17913a
movq %rsi, %rbx
movq %rdi, %r14
callq 0x172f0
cmpq $0x4, %rax
jne 0x17913a
movsbl (%r14), %edi
callq 0x11f92c
movsbl 0x1(%r14), %edi
callq 0x11f92c
movl $0x2d, %edi
callq 0x11f92c
movsbl 0x2(%r14), %edi
callq 0x11f92c
movsbl 0x3(%r14), %edi
callq 0x11f92c
movsd (%rsp), %xmm0
mulsd 0x1d06be(%rip), %xmm0   # 0x3497e0
leaq 0x21b108(%rip), %rdi    # 0x394231
movq %rbx, %rsi
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17070
callq 0x55995
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_intron_processed
bool gt_splice_site_info_visitor_intron_processed(GtNodeVisitor *nv)
{
  GtSpliceSiteInfoVisitor *ssiv;
  gt_assert(nv);
  ssiv = splice_site_info_visitor_cast(nv);
  return ssiv->intron_processed;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1791a9
movq %rdi, %rbx
callq 0x178cb8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
movb 0x31(%rax), %al
popq %rbx
retq
callq 0x55a07
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/splice_site_info_visitor.c
// Function: gt_splice_site_info_visitor_show_canonical
bool gt_splice_site_info_visitor_show_canonical(GtNodeVisitor *nv, bool show_gc)
{
  GtSpliceSiteInfoVisitor *ssiv;
  bool canonical_shown = false;
  gt_assert(nv);
  ssiv = splice_site_info_visitor_cast(nv);

  if (ssiv->show) {
    GtUword occ;
    if ((occ = gt_string_distri_get(ssiv->splicesites, "gtag"))) {
      printf("gt-ag: %6.2f%% (n="GT_WU")\n",
             gt_string_distri_get_prob(ssiv->splicesites, "gtag") * 100.0, occ);
      canonical_shown = true;
    }
    if (show_gc && (occ = gt_string_distri_get(ssiv->splicesites, "gcag"))) {
      printf("gc-ag: %6.2f%% (n="GT_WU")\n",
             gt_string_distri_get_prob(ssiv->splicesites, "gcag") * 100.0, occ);
      canonical_shown = true;
    }
  }

  return canonical_shown;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x179280
movl %esi, %r14d
movq %rdi, %rbx
callq 0x178cb8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
cmpb $0x1, 0x30(%rax)
jne 0x179271
movq %rax, %rbx
movq 0x18(%rax), %rdi
leaq 0x21b01e(%rip), %rsi    # 0x39420a
callq 0x11c3d4
testq %rax, %rax
setne %bpl
je 0x179226
movq %rax, %r15
movq 0x18(%rbx), %rdi
leaq 0x21b002(%rip), %rsi    # 0x39420a
callq 0x11c404
mulsd 0x1d05cb(%rip), %xmm0   # 0x3497e0
leaq 0x21aff3(%rip), %rdi    # 0x39420f
movq %r15, %rsi
movb $0x1, %al
callq 0x17070
testb %r14b, %r14b
je 0x179273
movq 0x18(%rbx), %rdi
leaq 0x21aff1(%rip), %rsi    # 0x394227
callq 0x11c3d4
testq %rax, %rax
je 0x179273
movq %rax, %r14
movq 0x18(%rbx), %rdi
leaq 0x21afd9(%rip), %rsi    # 0x394227
callq 0x11c404
mulsd 0x1d0585(%rip), %xmm0   # 0x3497e0
leaq 0x21afca(%rip), %rdi    # 0x39422c
movb $0x1, %bpl
movq %r14, %rsi
movb $0x1, %al
callq 0x17070
jmp 0x179273
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x55a40
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/squarealign.c
// Function: gt_squarealign_calculate_generic
GtUword gt_squarealign_calculate_generic (GtLinspaceManagement *spacemanager,
                                          GtAlignment *align,
                                          const GtUchar *useq,
                                          GtUword ustart,
                                          GtUword ulen,
                                          const GtUchar *vseq,
                                          GtUword vstart,
                                          GtUword vlen,
                                          const GtScoreHandler *scorehandler)
{
  GtUword **E, distance;
  gt_assert(align && scorehandler);

  if (spacemanager == NULL)
  {
    /*use it in normally case*/
    gt_array2dim_malloc(E, (ulen+1), (vlen+1));
  }
  else
  {
    /*use it in lineraspace context*/
    E = gt_linspace_management_change_to_square(spacemanager,ulen,vlen);
  }
  fillDPtab_in_square_space(E, useq, ustart, ulen,
                            vseq, vstart, vlen, scorehandler);

  distance = E[ulen][vlen];
  /* reconstruct alignment from 2dimarray E */
  gt_reconstructalignment_from_EDtab(align, E, useq, ustart, ulen, vseq, vstart,
                                     vlen, scorehandler);
  if (spacemanager == NULL)
  {
    gt_array2dim_delete(E);
  }
  return distance;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x1798f4
cmpq $0x0, 0x70(%rsp)
je 0x1798f4
movq %r9, %r12
movq %r8, %r15
movq %rsi, 0x20(%rsp)
movq %rdx, %rbp
movq %rcx, %r13
movq 0x68(%rsp), %rbx
testq %rdi, %rdi
movq %rdi, 0x18(%rsp)
je 0x1797da
movq %r15, %rsi
movq %rbx, %rdx
callq 0x15be6b
movq %rax, %r14
jmp 0x17985d
movq %r12, 0x8(%rsp)
leaq 0x1(%r15), %rax
movq %rax, 0x10(%rsp)
leaq 0x8(,%r15,8), %r12
leaq 0x21ae30(%rip), %rsi    # 0x394627
movq %r12, %rdi
movl $0x54, %edx
callq 0x104226
movq %rax, %r14
leaq 0x1(%rbx), %rdi
imulq %r12, %rdi
leaq 0x21ae11(%rip), %rsi    # 0x394627
movl $0x54, %edx
callq 0x104226
movq %rax, (%r14)
cmpq $0x2, 0x10(%rsp)
jb 0x179858
movq %rbx, %rsi
leaq 0x8(,%rbx,8), %rax
movq (%r14), %rcx
addq %rax, %rcx
xorl %edx, %edx
movq 0x8(%rsp), %r12
movq %rcx, 0x8(%r14,%rdx,8)
addq %rax, %rcx
incq %rdx
cmpq %rdx, %r15
jne 0x179843
movq %rsi, %rbx
jmp 0x17985d
movq 0x8(%rsp), %r12
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %r12, %r8
movq 0x60(%rsp), %r9
movq 0x70(%rsp), %rax
pushq %rax
pushq %rbx
callq 0x1798f9
addq $0x10, %rsp
movq (%r14,%r15,8), %rax
movq %r12, %r9
movq (%rax,%rbx,8), %r12
subq $0x8, %rsp
movq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
pushq 0x78(%rsp)
pushq %rbx
pushq 0x78(%rsp)
callq 0x16cd5a
addq $0x20, %rsp
cmpq $0x0, 0x18(%rsp)
jne 0x1798e2
movq (%r14), %rdi
leaq 0x21ad62(%rip), %rbx    # 0x394627
movq %rbx, %rsi
movl $0x64, %edx
callq 0x1045eb
movq %r14, %rdi
movq %rbx, %rsi
movl $0x64, %edx
callq 0x1045eb
movq %r12, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x55d0f