LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrf_abbr_entry.c
// Function: gt_xrf_abbr_entry_add
void gt_xrf_abbr_entry_add(GtXRFAbbrEntry *abbr_entry, const char *tag,
                           const char *value)
{
  GtStr *s;
  gt_assert(abbr_entry && tag && value);
  if (!(s = gt_hashmap_get(abbr_entry->content, tag))) {
    s = gt_str_new_cstr(value);
    gt_hashmap_add(abbr_entry->content, gt_cstr_dup(tag), s);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x86694
movq %rsi, %rbx
testq %rsi, %rsi
je 0x86694
movq %rdx, %r15
testq %rdx, %rdx
je 0x86694
movq %rdi, %r14
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
je 0x8666b
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x3b785
movq %rax, %r15
movq (%r14), %r14
movq %rbx, %rdi
callq 0x728c0
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x77628
callq 0x1fc27
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrf_abbr_entry.c
// Function: gt_xrf_abbr_entry_get_value
const char* gt_xrf_abbr_entry_get_value(const GtXRFAbbrEntry *abbr_entry,
                                        const char *entry_key)
{
  GtStr *s;
  gt_assert(abbr_entry);
  if ((s = gt_hashmap_get(abbr_entry->content, entry_key)))
    return gt_str_get(s);
  return NULL;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x866b9
movq (%rdi), %rdi
callq 0x775ed
testq %rax, %rax
je 0x866b5
movq %rax, %rdi
popq %rax
jmp 0x3bb5d
xorl %eax, %eax
popq %rcx
retq
callq 0x1fc5e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrf_abbr_parse_tree.c
// Function: gt_xrf_abbr_parse_tree_delete
void gt_xrf_abbr_parse_tree_delete(GtXRFAbbrParseTree *xrf_abbr_parse_tree)
{
  GtUword i;
  if (!xrf_abbr_parse_tree) return;
  for (i = 0; i < gt_array_size(xrf_abbr_parse_tree->entries); i++) {
    gt_xrf_abbr_entry_delete(*(GtXRFAbbrEntry**)
                         gt_array_get(xrf_abbr_parse_tree->entries, i));
  }
  gt_array_delete(xrf_abbr_parse_tree->entries);
  gt_free(xrf_abbr_parse_tree);
}

// Assembly:
testq %rdi, %rdi
je 0x86f4e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6f310
testq %rax, %rax
je 0x86f2b
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x86608
incq %r14
movq (%rbx), %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x86f08
movq (%rbx), %rdi
callq 0x6f768
leaq 0x6e025(%rip), %rsi     # 0xf4f5f
movq %rbx, %rdi
movl $0x198, %edx            # imm = 0x198
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrf_abbr_parse_tree.c
// Function: gt_xrf_abbr_parse_tree_get_entry_value
const char* gt_xrf_abbr_parse_tree_get_entry_value(const GtXRFAbbrParseTree
                                                           *xrf_abbr_parse_tree,
                                                   GtUword entry_num,
                                                   const char *entry_key)
{
  gt_assert(xrf_abbr_parse_tree);
  return gt_xrf_abbr_entry_get_value(*(GtXRFAbbrEntry**)
                                      gt_array_get(xrf_abbr_parse_tree->entries,
                                                   entry_num), entry_key);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x86f6c
movq %rdx, %rbx
movq (%rdi), %rdi
callq 0x6f037
movq (%rax), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x86699
callq 0x1ff39
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrf_abbr_parse_tree.c
// Function: gt_xrf_abbr_parse_tree_blank_line
static int gt_xrf_abbr_parse_tree_blank_line(GtIO *xrf_abbr_file, GtError *err)
{
  int had_err;
  gt_error_check(err);
  gt_log_log("blank");
  had_err = gt_io_expect(xrf_abbr_file, XRF_BLANK_CHAR, err);
  while (!had_err) {
    char cc = gt_io_peek(xrf_abbr_file);
    if (cc == XRF_COMMENT_CHAR)
      return gt_xrf_abbr_parse_tree_comment_line(xrf_abbr_file, err);
    else if (cc == GT_CARRIAGE_RETURN) {
      gt_io_next(xrf_abbr_file);
      if (gt_io_peek(xrf_abbr_file) == GT_END_OF_LINE)
        gt_io_next(xrf_abbr_file);
      break;
    }
    else if ((cc == GT_END_OF_LINE) || (cc == GT_END_OF_FILE)) {
      gt_io_next(xrf_abbr_file);
      break;
    }
    else
      had_err = gt_io_expect(xrf_abbr_file, XRF_BLANK_CHAR, err);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x86fbb
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x87046
leaq 0x6e0dc(%rip), %rdi     # 0xf509e
xorl %eax, %eax
callq 0x353ae
movq %rbx, %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0xa472f
testl %eax, %eax
jne 0x87011
movq %rbx, %rdi
callq 0xa468f
movzbl %al, %eax
cmpl $0x20, %eax
jg 0x86ff9
cmpl $0xa, %eax
je 0x8701a
cmpl $0xd, %eax
jne 0x86fc9
jmp 0x87026
cmpl $0xff, %eax
je 0x8701a
cmpl $0x21, %eax
jne 0x86fc9
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x8704b
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0xa46c8
xorl %ebp, %ebp
jmp 0x87013
movq %rbx, %rdi
callq 0xa46c8
movq %rbx, %rdi
callq 0xa468f
xorl %ebp, %ebp
cmpb $0xa, %al
jne 0x87013
movq %rbx, %rdi
callq 0xa46c8
jmp 0x87013
callq 0x1ffe4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrf_abbr_parse_tree.c
// Function: gt_xrf_abbr_parse_tree_comment_line
static int gt_xrf_abbr_parse_tree_comment_line(GtIO *xrf_abbr_file,
                                               GtError *err)
{
  int had_err;
  gt_error_check(err);
  gt_log_log("comment");
  had_err = gt_io_expect(xrf_abbr_file, XRF_COMMENT_CHAR, err);
  while (!had_err) {
    switch (gt_io_peek(xrf_abbr_file)) {
      case GT_CARRIAGE_RETURN:
        gt_io_next(xrf_abbr_file);
        if (gt_io_peek(xrf_abbr_file) == GT_END_OF_LINE)
          gt_io_next(xrf_abbr_file);
        return had_err;
      case GT_END_OF_LINE:
        gt_io_next(xrf_abbr_file);
        /*@fallthrough@*/
      case GT_END_OF_FILE:
        return had_err;
      default:
        gt_io_next(xrf_abbr_file);
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x87066
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x870d1
leaq 0x66f46(%rip), %rdi     # 0xedfb3
xorl %eax, %eax
callq 0x353ae
movq %rbx, %rdi
movl $0x21, %esi
movq %r14, %rdx
callq 0xa472f
movl %eax, %ebp
testl %eax, %eax
jne 0x870ca
jmp 0x870a3
movzbl %al, %eax
cmpl $0xff, %eax
je 0x870ca
movq %rbx, %rdi
cmpl $0xd, %eax
je 0x870b1
callq 0xa46c8
movq %rbx, %rdi
callq 0xa468f
cmpb $0xa, %al
jne 0x8708c
jmp 0x870c2
callq 0xa46c8
movq %rbx, %rdi
callq 0xa468f
cmpb $0xa, %al
jne 0x870ca
movq %rbx, %rdi
callq 0xa46c8
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2001d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrf_abbr_parse_tree.c
// Function: gt_xrf_abbr_parse_tree_proc_any_char
static int gt_xrf_abbr_parse_tree_proc_any_char(GtIO *xrf_abbr_file,
                                                GtStr *capture,
                                                bool be_permissive,
                                                GtError *err)
{
  gt_error_check(err);
  gt_assert(xrf_abbr_file && capture);
  if (!gt_xrf_abbr_parse_tree_any_char(xrf_abbr_file, be_permissive)) {
    if (gt_io_peek(xrf_abbr_file) == GT_END_OF_FILE) {
      gt_error_set(err, "file \"%s\": line "GT_WU": unexpected end-of-file",
                gt_io_get_filename(xrf_abbr_file),
                gt_io_get_line_number(xrf_abbr_file));
    }
    else if ((gt_io_peek(xrf_abbr_file) == GT_CARRIAGE_RETURN) ||
             (gt_io_peek(xrf_abbr_file) == GT_END_OF_LINE)) {
      gt_error_set(err, "file \"%s\": line "GT_WU": unexpected newline",
                gt_io_get_filename(xrf_abbr_file),
                gt_io_get_line_number(xrf_abbr_file));
    }
    else {
      gt_error_set(err, "file \"%s\": line "GT_WU": unexpected character '%c'",
                gt_io_get_filename(xrf_abbr_file),
                gt_io_get_line_number(xrf_abbr_file),
                gt_io_peek(xrf_abbr_file));
    }
    return -1;
  }
  gt_str_append_char(capture, gt_io_next(xrf_abbr_file));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
testq %rcx, %rcx
je 0x870fe
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x8720e
testq %r15, %r15
je 0x87209
movq %r14, %rdi
callq 0xa468f
movzbl %al, %eax
cmpb $0x3a, %al
ja 0x87152
movabsq $0x200002400, %rcx      # imm = 0x200002400
btq %rax, %rcx
jb 0x87159
movabsq $0x400000100000000, %rcx # imm = 0x400000100000000
btq %rax, %rcx
jae 0x87152
testb %bpl, %bpl
je 0x87159
movq %r14, %rdi
callq 0xa46c8
movsbl %al, %esi
movq %r15, %rdi
callq 0x3b9df
xorl %eax, %eax
jmp 0x871c5
cmpl $0xff, %eax
jne 0x8713b
movq %r14, %rdi
callq 0xa468f
movq %r14, %rdi
cmpb $-0x1, %al
je 0x87199
callq 0xa468f
cmpb $0xd, %al
je 0x8717d
movq %r14, %rdi
callq 0xa468f
cmpb $0xa, %al
jne 0x871ce
movq %r14, %rdi
callq 0xa4702
movq %rax, %r15
movq %r14, %rdi
callq 0xa46f2
leaq 0x6e077(%rip), %rsi     # 0xf520e
jmp 0x871b0
callq 0xa4702
movq %rax, %r15
movq %r14, %rdi
callq 0xa46f2
leaq 0x6e032(%rip), %rsi     # 0xf51e2
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xa4702
movq %rax, %r15
movq %r14, %rdi
callq 0xa46f2
movq %rax, %r12
movq %r14, %rdi
callq 0xa468f
movsbl %al, %r8d
leaq 0x6e03f(%rip), %rsi     # 0xf5236
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x34f1f
jmp 0x871c0
callq 0x2008f
callq 0x20056
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_tostring
static int genome_node_lua_tostring (lua_State *L)
{
  GtGenomeNode **gn;
  char buf[BUFSIZ];
  gn = check_genome_node(L, 1);
  if (gt_feature_node_try_cast(*gn)) {
    GtFeatureNode *fn = gt_feature_node_try_cast(*gn);
    (void) snprintf(buf, BUFSIZ, "feature: %s "GT_WU"-"GT_WU" %c",
                    gt_feature_node_get_type(fn),
                    gt_genome_node_get_start(*gn),
                    gt_genome_node_get_end(*gn),
                    GT_STRAND_CHARS[gt_feature_node_get_strand(fn)]);
  } else if (gt_region_node_try_cast(*gn)) {
    GtRange rng = gt_genome_node_get_range(*gn);
    (void) snprintf(buf, BUFSIZ, "region: %s "GT_WU"-"GT_WU,
                    gt_str_get(gt_genome_node_get_seqid(*gn)),
                    rng.start, rng.end);
  }
  lua_pushfstring(L, "%s", buf);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
movq %rdi, %rbx
leaq 0x6e022(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq (%rax), %rdi
callq 0x40c37
movq (%r14), %rdi
testq %rax, %rax
je 0x8747f
callq 0x40c37
movq %rax, %r12
movq %rax, %rdi
callq 0x3f914
movq %rax, %r15
movq (%r14), %rdi
callq 0x415e0
movq %rax, %r13
movq (%r14), %rdi
callq 0x41603
movq %rax, %r14
movq %r12, %rdi
callq 0x3f462
movl %eax, %eax
leaq 0x5b6e8(%rip), %rcx     # 0xe2b44
movsbl (%rax,%rcx), %eax
movl %eax, (%rsp)
leaq 0x6e026(%rip), %rdx     # 0xf5490
leaq 0x10(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rcx
movq %r13, %r8
movq %r14, %r9
jmp 0x874c1
callq 0x49700
testq %rax, %rax
je 0x874c8
movq (%r14), %rdi
callq 0x415e5
movq %rax, %r15
movq %rdx, %r12
movq (%r14), %rdi
callq 0x415a1
movq %rax, %rdi
callq 0x3bb5d
leaq 0x6dff9(%rip), %rdx     # 0xf54a7
leaq 0x10(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %rax, %rcx
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
callq 0xba10
leaq 0x67632(%rip), %rsi     # 0xeeb01
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x57c58
movl $0x1, %eax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_eq
static int genome_node_lua_eq(lua_State *L)
{
  GtGenomeNode **gn1, **gn2;
  bool ret = false;
  gt_assert(L);
  gn1 = check_genome_node(L, 1);
  gn2 = check_genome_node(L, 2);
  if (*gn1 == *gn2)
    ret = true;
  lua_pushboolean(L, ret);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x87547
movq %rdi, %rbx
leaq 0x6df1f(%rip), %r14     # 0xf5427
movl $0x1, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5a67c
movq (%r15), %rcx
xorl %esi, %esi
cmpq (%rax), %rcx
sete %sil
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2013a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_get_children_gc
static int feature_node_lua_get_children_gc(lua_State *L)
{
  GtFeatureNodeIterator *it;
  it = *(GtFeatureNodeIterator**) lua_touserdata(L, 1);
  if (it)
    gt_feature_node_iterator_delete(it);
  return 0;
}

// Assembly:
pushq %rax
movl $0x1, %esi
callq 0x57668
movq (%rax), %rdi
testq %rdi, %rdi
je 0x87564
callq 0x41108
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_each_attribute_gc
static int feature_node_lua_each_attribute_gc(lua_State *L) {
  GtFeatureNodeLuaEachAttribInfo *info;
  info = *(GtFeatureNodeLuaEachAttribInfo**) lua_touserdata(L, 1);
  if (info) {
    gt_str_array_delete(info->attribs);
    gt_genome_node_delete((GtGenomeNode*) info->fn);
    gt_free(info);
  }
  return 0;
}

// Assembly:
pushq %rbx
movl $0x1, %esi
callq 0x57668
movq (%rax), %rbx
testq %rbx, %rbx
je 0x875a1
movq 0x8(%rbx), %rdi
callq 0x3cc00
movq 0x10(%rbx), %rdi
callq 0x4210c
leaq 0x6de77(%rip), %rsi     # 0xf540b
movq %rbx, %rdi
movl $0x1d9, %edx            # imm = 0x1D9
callq 0x35c27
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: gt_lua_genome_node_push
void gt_lua_genome_node_push(lua_State *L, GtGenomeNode *gn)
{
  GtGenomeNode **gn_lua;
  gt_assert(L && gn);
  gn_lua = lua_newuserdata(L, sizeof (GtGenomeNode**));
  *gn_lua = gn;
  luaL_getmetatable(L, GENOME_NODE_METATABLE);
  lua_setmetatable(L, -2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x875ee
movq %rsi, %r14
testq %rsi, %rsi
je 0x875ee
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
movq %r14, (%rax)
leaq 0x6de5a(%rip), %rdx     # 0xf5427
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x586d6
callq 0x20173
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_set_range
static int genome_node_lua_set_range(lua_State *L)
{
  GtRange *rng;
  GtGenomeNode **gn = check_genome_node(L, 1);
  rng = check_range(L, 2);
  gt_genome_node_set_range(*gn, rng);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6dd9b(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
leaq 0x6de81(%rip), %rdx     # 0xf5521
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a67c
movq (%r14), %rdi
movq %rax, %rsi
callq 0x41646
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_get_seqid
static int genome_node_lua_get_seqid(lua_State *L)
{
  GtStr *seqid;
  GtGenomeNode **gn = check_genome_node(L, 1);
  if ((seqid = gt_genome_node_get_seqid(*gn)))
    lua_pushstring(L, gt_str_get(seqid));
  else
    lua_pushnil(L);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6dd5a(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x415a1
testq %rax, %rax
je 0x876f9
movq %rax, %rdi
callq 0x3bb5d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
jmp 0x87701
movq %rbx, %rdi
callq 0x57704
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_change_seqid
static int genome_node_lua_change_seqid(lua_State *L)
{
  const char *seqid;
  GtStr *seqid_str;
  GtGenomeNode **gn = check_genome_node(L, 1);
  seqid = luaL_checkstring(L, 2);
  seqid_str = gt_str_new_cstr(seqid);
  gt_genome_node_change_seqid(*gn, seqid_str);
  gt_str_delete(seqid_str);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6dd11(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %rdi
callq 0x3b785
movq %rax, %rbx
movq (%r14), %rdi
movq %rax, %rsi
callq 0x41675
movq %rbx, %rdi
callq 0x3c87b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_get_strand
static int feature_node_lua_get_strand(lua_State *L)
{
  GtGenomeNode **gn = check_genome_node(L, 1);
  GtFeatureNode *fn;
  char strand_char[2];
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  strand_char[0] = GT_STRAND_CHARS[gt_feature_node_get_strand(fn)];
  strand_char[1] = '\0';
  lua_pushstring(L, strand_char);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6dcbf(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x87796
leaq 0x6ddaa(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x3f462
movl %eax, %eax
leaq 0x5b39d(%rip), %rcx     # 0xe2b44
movb (%rax,%rcx), %al
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rbx, %rdi
callq 0x5790a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_set_strand
static int feature_node_lua_set_strand(lua_State *L)
{
  const char *str;
  GtGenomeNode **gn = check_genome_node(L, 1);
  GtFeatureNode *fn;
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  str = luaL_checkstring(L, 2);
  luaL_argcheck(L, strlen(str) == 1 && strchr(GT_STRAND_CHARS, str[0]),
                2, "must be one of '" GT_STRAND_CHARS "'");
  gt_feature_node_set_strand(fn, gt_strand_get(str[0]));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x6dc4c(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %rbx
testq %rax, %rax
jne 0x87809
leaq 0x6dd37(%rip), %rdx     # 0xf5533
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movq %rax, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x87846
movb (%r15), %bpl
movsbl %bpl, %esi
leaq 0x5b30d(%rip), %rdi     # 0xe2b44
movl $0x5, %edx
callq 0xb710
testq %rax, %rax
jne 0x8785d
leaq 0x6dcf9(%rip), %rdx     # 0xf5546
movq %r14, %rdi
movl $0x2, %esi
callq 0x5a2e1
movb (%r15), %bpl
movsbl %bpl, %edi
callq 0x3cc78
movq %rbx, %rdi
movl %eax, %esi
callq 0x3fc8d
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/gtlua/genome_node_lua.c
// Function: feature_node_lua_get_source
static int feature_node_lua_get_source(lua_State *L)
{
  GtGenomeNode **gn = check_genome_node(L, 1);
  GtFeatureNode *fn;
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  lua_pushstring(L, gt_feature_node_get_source(fn));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6db9c(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x878b9
leaq 0x6dc87(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x3fa40
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_set_source
static int feature_node_lua_set_source(lua_State *L)
{
  const char *source;
  GtStr *source_str;
  GtGenomeNode **gn = check_genome_node(L, 1);
  GtFeatureNode *fn;
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  source = luaL_checkstring(L, 2);
  source_str = gt_str_new_cstr(source);
  gt_feature_node_set_source(fn, source_str);
  gt_str_delete(source_str);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6db40(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x87915
leaq 0x6dc2b(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %rdi
callq 0x3b785
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3ef41
movq %rbx, %rdi
callq 0x3c87b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_get_score
static int feature_node_lua_get_score(lua_State *L)
{
  GtGenomeNode **gn = check_genome_node(L, 1);
  GtFeatureNode *fn;
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  if (gt_feature_node_score_is_defined(fn))
    lua_pushnumber(L, gt_feature_node_get_score(fn));
  else
    lua_pushnil(L);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6dacd(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x87988
leaq 0x6dbb8(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x3f954
testb %al, %al
je 0x879aa
movq %r14, %rdi
callq 0x3fc4f
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x57718
jmp 0x879b2
movq %rbx, %rdi
callq 0x57704
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_set_score
static int feature_node_lua_set_score(lua_State *L)
{
  float sc;
  GtGenomeNode **gn = check_genome_node(L, 1);
  GtFeatureNode *fn;
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  sc = luaL_checknumber(L, 2);
  gt_feature_node_set_score(fn, sc);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6da5a(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x879fb
leaq 0x6db45(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a7b9
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x3f968
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_get_phase
static int feature_node_lua_get_phase(lua_State *L)
{
  GtGenomeNode **gn = check_genome_node(L, 1);
  GtFeatureNode *fn;
  GtPhase phase;
  char phasebuf[2];
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  phase = gt_feature_node_get_phase(fn);
  phasebuf[0] = GT_PHASE_CHARS[(int) phase];
  phasebuf[1] = '\0';
  lua_pushstring(L, phasebuf);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d9fb(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x87a5a
leaq 0x6dae6(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x3fcc6
cltq
leaq 0x5b185(%rip), %rcx     # 0xe2bf0
movb (%rax,%rcx), %al
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rbx, %rdi
callq 0x5790a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_set_phase
static int feature_node_lua_set_phase(lua_State *L)
{
  const char *p;
  GtGenomeNode **gn = check_genome_node(L, 1);
  GtFeatureNode *fn;
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  p = luaL_checkstring(L, 2);
  luaL_argcheck(L, strlen(p) == 1 && strchr(GT_PHASE_CHARS, p[0]),
                2, "must be one of '" GT_PHASE_CHARS "'");
  gt_feature_node_set_phase(fn, gt_phase_get(p[0]));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x6d988(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %rbx
testq %rax, %rax
jne 0x87acd
leaq 0x6da73(%rip), %rdx     # 0xf5533
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movq %rax, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x87b0a
movb (%r15), %bpl
movsbl %bpl, %esi
leaq 0x5b0f5(%rip), %rdi     # 0xe2bf0
movl $0x5, %edx
callq 0xb710
testq %rax, %rax
jne 0x87b21
leaq 0x6da4b(%rip), %rdx     # 0xf555c
movq %r14, %rdi
movl $0x2, %esi
callq 0x5a2e1
movb (%r15), %bpl
movsbl %bpl, %edi
callq 0x39d90
movq %rbx, %rdi
movl %eax, %esi
callq 0x3efa4
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/gtlua/genome_node_lua.c
// Function: feature_node_lua_get_attribute
static int feature_node_lua_get_attribute(lua_State *L)
{
  GtGenomeNode **gn = check_genome_node(L, 1);
  const char *attr = NULL, *attrval = NULL;
  attr = luaL_checkstring(L, 2);
  GtFeatureNode *fn;
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  attrval = gt_feature_node_get_attribute(fn, attr);
  if (attrval)
    lua_pushstring(L, attrval);
  else
    lua_pushnil(L);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6d8d7(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r14
movq (%r15), %rdi
callq 0x40c37
movq %rax, %r15
testq %rax, %rax
jne 0x87b93
leaq 0x6d9ad(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r15, %rdi
movq %r14, %rsi
callq 0x3eedc
movq %rbx, %rdi
testq %rax, %rax
je 0x87bb0
movq %rax, %rsi
callq 0x5790a
jmp 0x87bb5
callq 0x57704
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_get_exons
static int feature_node_lua_get_exons(lua_State *L)
{
  GtGenomeNode **gn = check_genome_node(L, 1);
  GtArray *exons = gt_array_new(sizeof (GtGenomeNode*));
  GtUword i = 0;
  GtFeatureNode *fn;
  /* make sure we get a feature node */
  fn = gt_feature_node_try_cast(*gn);
  luaL_argcheck(L, fn, 1, "not a feature node");
  gt_feature_node_get_exons(fn, exons);
  lua_newtable(L);
  for (i = 0; i < gt_array_size(exons); i++) {
    lua_pushnumber(L, i+1);
    gt_lua_genome_node_push(L, (GtGenomeNode*)
                            gt_genome_node_ref(*(GtGenomeNode**)
                                               gt_array_get(exons, i)));
    lua_rawset(L, -3);
  }
  gt_array_delete(exons);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d855(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %r14
movq (%r15), %rdi
callq 0x40c37
movq %rax, %r15
testq %rax, %rax
jne 0x87c10
leaq 0x6d930(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r15, %rdi
movq %r14, %rsi
callq 0x3fcdb
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58130
movq %r14, %rdi
callq 0x6f310
testq %rax, %rax
je 0x87c9f
xorl %r15d, %r15d
leaq 0x1(%r15), %r12
movq %r12, %xmm1
punpckldq 0x59838(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x59840(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57718
movq %r14, %rdi
movq %r15, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x4130c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x875a5
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58524
movq %r14, %rdi
callq 0x6f310
movq %r12, %r15
cmpq %rax, %r12
jb 0x87c37
movq %r14, %rdi
callq 0x6f768
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_accept
static int genome_node_lua_accept(lua_State *L)
{
  GtGenomeNode **gn;
  GtNodeVisitor **gv;
  GtError *err;
  gn = check_genome_node(L, 1);
  gv = check_genome_visitor(L, 2);
  err = gt_error_new();
  if (gt_genome_node_accept(*gn, *gv, err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d75d(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
leaq 0x6d894(%rip), %rdx     # 0xf5572
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a67c
movq %rax, %r12
callq 0x34f04
movq %rax, %r14
movq (%r15), %rdi
movq (%r12), %rsi
movq %rax, %rdx
callq 0x41698
testl %eax, %eax
je 0x87d1f
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa7d4a
movq %r14, %rdi
callq 0x35085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_add_attribute
static int genome_node_lua_add_attribute(lua_State *L)
{
  GtGenomeNode **node;
  const char *key, *val;
  GtFeatureNode *f;
  node = check_genome_node(L, 1);
  f = gt_feature_node_try_cast(*node);
  luaL_argcheck(L, f, 1, "not a feature node");
  key = luaL_checkstring(L, 2);
  luaL_argcheck(L, !gt_feature_node_get_attribute(f, key), 2,
                "attribute already present");
  val = luaL_checkstring(L, 3);
  gt_feature_node_add_attribute(f, key, val);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6d6e3(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x87d72
leaq 0x6d7ce(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x3eedc
testq %rax, %rax
je 0x87da8
leaq 0x6d7f2(%rip), %rdx     # 0xf558d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40229
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_remove_attribute
static int genome_node_lua_remove_attribute(lua_State *L)
{
  GtGenomeNode **node;
  const char *key;
  GtFeatureNode *f;
  node = check_genome_node(L, 1);
  f = gt_feature_node_try_cast(*node);
  luaL_argcheck(L, f, 1, "not a feature node");
  key = luaL_checkstring(L, 2);
  luaL_argcheck(L, gt_feature_node_get_attribute(f, key), 2,
                "attribute not present in node");
  gt_feature_node_remove_attribute(f, key);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6d64b(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x87e0a
leaq 0x6d736(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x3eedc
testq %rax, %rax
jne 0x87e40
leaq 0x6d774(%rip), %rdx     # 0xf55a7
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq %r14, %rdi
movq %r15, %rsi
callq 0x402d5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_set_attribute
static int genome_node_lua_set_attribute(lua_State *L)
{
  GtGenomeNode **node;
  const char *key, *val;
  GtFeatureNode *f;
  node = check_genome_node(L, 1);
  f = gt_feature_node_try_cast(*node);
  luaL_argcheck(L, f, 1, "not a feature node");
  key = luaL_checkstring(L, 2);
  luaL_argcheck(L, strlen(key) > 0, 2,
                "key must have length > 0");
  val = luaL_checkstring(L, 3);
  luaL_argcheck(L, strlen(key) > 0, 3,
                "value must have length > 0");
  gt_feature_node_set_attribute(f, key, val);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d5c2(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x87e93
leaq 0x6d6ad(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x87ebe
leaq 0x6d714(%rip), %rdx     # 0xf55c5
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r12
cmpb $0x0, (%r15)
jne 0x87eea
leaq 0x6d701(%rip), %rdx     # 0xf55de
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3f99b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_add_child
static int genome_node_lua_add_child(lua_State *L)
{
  GtGenomeNode **parent, **child;
  GtFeatureNode *pf, *cf;
  parent = check_genome_node(L, 1);
  child  = check_genome_node(L, 2);
  pf = gt_feature_node_try_cast(*parent);
  luaL_argcheck(L, pf, 1, "not a feature node");
  cf = gt_feature_node_try_cast(*child);
  luaL_argcheck(L, cf, 2, "not a feature node");
  luaL_argcheck(L,
               !strcmp(gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) pf)),
                      gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) cf))),
                2, "has a sequence ID different to the one of its parent");
  gt_feature_node_add_child(pf, (GtFeatureNode*)
                                gt_genome_node_ref((GtGenomeNode*) cf));
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d50f(%rip), %r14     # 0xf5427
movl $0x1, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r15
movq (%r12), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x87f60
leaq 0x6d5e0(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq (%r15), %rdi
callq 0x40c37
movq %rax, %r15
testq %rax, %rax
jne 0x87f84
leaq 0x6d5bc(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x415a1
movq %rax, %rdi
callq 0x3bb5d
movq %rax, %r12
movq %r15, %rdi
callq 0x415a1
movq %rax, %rdi
callq 0x3bb5d
movq %r12, %rdi
movq %rax, %rsi
callq 0xb890
testl %eax, %eax
je 0x87fca
leaq 0x6d63c(%rip), %rdx     # 0xf55f9
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq %r15, %rdi
callq 0x4130c
movq %r14, %rdi
movq %rax, %rsi
callq 0x3f6eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: genome_node_lua_contains_marked
static int genome_node_lua_contains_marked(lua_State *L)
{
  GtGenomeNode **gn;
  gn = check_genome_node(L, 1);
  lua_pushboolean(L,
                  gt_feature_node_contains_marked(gt_feature_node_cast(*gn)));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x6d3d4(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x3f369
movq %rax, %rdi
callq 0x40ae3
movzbl %al, %esi
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_output_leading
static int feature_node_lua_output_leading(lua_State *L)
{
  GtGenomeNode **gn;
  GtFeatureNode *fn;
  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");
  gt_gff3_output_leading(fn, NULL);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d39a(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x880bb
leaq 0x6d485(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
xorl %esi, %esi
callq 0x858a4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_get_type
static int feature_node_lua_get_type(lua_State *L)
{
  GtGenomeNode **gn;
  GtFeatureNode *fn;
  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_pushstring(L, gt_feature_node_get_type(fn));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d34a(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x8810b
leaq 0x6d435(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x3f914
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_set_type
static int feature_node_lua_set_type(lua_State *L)
{
  GtGenomeNode **gn;
  const char *type = NULL;
  GtFeatureNode *fn;
  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");
  type = luaL_checkstring(L, 2);
  gt_assert(type);
  luaL_argcheck(L, strlen(type) > 0, 2, "must not be empty");
  gt_feature_node_set_type(fn, type);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6d2ed(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x88168
leaq 0x6d3d8(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
testq %rax, %rax
je 0x881ab
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x88198
leaq 0x7ee2a(%rip), %rdx     # 0x106fb5
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq %r14, %rdi
movq %r15, %rsi
callq 0x3fa60
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x201ac
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_each_attribute
static int feature_node_lua_each_attribute(lua_State *L) {
  GtGenomeNode **gn;
  GtFeatureNode *fn;
  GtFeatureNodeLuaEachAttribInfo **info;
  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");
  info = (GtFeatureNodeLuaEachAttribInfo**) lua_newuserdata(L,
                                     sizeof (GtFeatureNodeLuaEachAttribInfo *));
  luaL_getmetatable(L, "GenomeTools.each_attrib");
  lua_setmetatable(L, -2);
  *info = gt_calloc(1, sizeof (GtFeatureNodeLuaEachAttribInfo));
  gt_assert(*info);
  (*info)->fn = (GtFeatureNode*) gt_genome_node_ref(*gn);
  (*info)->cur_attr = 0;
  (*info)->attribs = gt_feature_node_get_attribute_list(fn);
  lua_pushcclosure(L, feature_node_lua_each_attribute_iter, 1);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d244(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x88214
leaq 0x6d32c(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
movq %rax, %r12
leaq 0x6d22d(%rip), %rdx     # 0xf5458
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
leaq 0x6d1bf(%rip), %rdx     # 0xf540b
movl $0x1, %edi
movl $0x18, %esi
movl $0x1ea, %ecx            # imm = 0x1EA
callq 0x359a6
movq %rax, (%r12)
testq %rax, %rax
je 0x882b9
movq (%r15), %rdi
callq 0x4130c
movq (%r12), %rcx
movq %rax, 0x10(%rcx)
movq (%r12), %rax
movq $0x0, (%rax)
movq %r14, %rdi
callq 0x3eeec
movq (%r12), %rcx
movq %rax, 0x8(%rcx)
leaq 0x723(%rip), %rsi       # 0x889be
movq %rbx, %rdi
movl $0x1, %edx
callq 0x57d08
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x201e5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_has_child_of_type
static int feature_node_lua_has_child_of_type(lua_State *L)
{
  GtGenomeNode **gn;
  GtFeatureNode *fn, GT_UNUSED *fn2 = NULL;
  GtFeatureNodeIterator *it;
  bool found = false;
  const char *type;

  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");
  type = gt_symbol(luaL_checkstring(L, 2));
  it = gt_feature_node_iterator_new(fn);
  /* skip parent node itself */
  fn2 = gt_feature_node_iterator_next(it);
  gt_assert(fn2);
  while (!found && (fn2 = gt_feature_node_iterator_next(it))) {
    found = (gt_feature_node_get_type(fn2) == type);
  }
  gt_feature_node_iterator_delete(it);
  lua_pushboolean(L, found);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x6d157(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x882fe
leaq 0x6d242(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %rdi
callq 0x3cd3b
movq %rax, %r15
movq %r14, %rdi
callq 0x40ee0
movq %rax, %r14
movq %rax, %rdi
callq 0x41076
testq %rax, %rax
je 0x88376
movq %r14, %rdi
callq 0x41076
movq %rax, %r12
testq %rax, %rax
je 0x8834d
movq %r12, %rdi
callq 0x3f914
cmpq %r15, %rax
jne 0x88330
xorl %ebp, %ebp
testq %r12, %r12
setne %bpl
movq %r14, %rdi
callq 0x41108
movq %rbx, %rdi
movl %ebp, %esi
callq 0x57df3
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2021e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_extract_sequence
static int feature_node_lua_extract_sequence(lua_State *L)
{
  GtGenomeNode **gn;
  GtFeatureNode *fn;
  const char *type;
  bool join;
  GtRegionMapping **region_mapping;
  GtStr *sequence;
  GtError *err;
  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");
  type = luaL_checkstring(L, 2);
  join = lua_toboolean(L, 3);
  region_mapping = check_region_mapping(L, 4);
  err = gt_error_new();
  sequence = gt_str_new();
  if (gt_extract_feature_sequence(sequence, *gn, gt_symbol(type), join,
                                  NULL, NULL, *region_mapping, err)) {
    gt_str_delete(sequence);
    return gt_lua_error(L, err);
  }
  lua_pushstring(L, gt_str_get(sequence));
  gt_str_delete(sequence);
  gt_error_delete(err);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6d097(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq (%rax), %rdi
callq 0x40c37
testq %rax, %rax
jne 0x883be
leaq 0x6d182(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, (%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x573d2
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
leaq 0x6d2f7(%rip), %rdx     # 0xf56e4
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a67c
movq %rax, %r13
callq 0x34f04
movq %rax, %r15
callq 0x3b728
movq %rax, %r12
movq (%r14), %r14
movq (%rsp), %rdi
callq 0x3cd3b
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r15
pushq (%r13)
callq 0xa72ec
addq $0x10, %rsp
testl %eax, %eax
je 0x8845e
movq %r12, %rdi
callq 0x3c87b
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa7d4a
movq %r12, %rdi
callq 0x3bb5d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movq %r12, %rdi
callq 0x3c87b
movq %r15, %rdi
callq 0x35085
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_extract_and_translate_sequence
static int feature_node_lua_extract_and_translate_sequence(lua_State *L)
{
  GtGenomeNode **gn;
  GtFeatureNode *fn;
  const char *type;
  bool join;
  GtRegionMapping **region_mapping;
  GtStr *sequence;
  GtError *err;
  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");
  type = luaL_checkstring(L, 2);
  join = lua_toboolean(L, 3);
  region_mapping = check_region_mapping(L, 4);
  err = gt_error_new();
  sequence = gt_str_new();
  if (gt_extract_and_translate_feature_sequence(fn, gt_symbol(type), join,
                                                NULL, NULL, *region_mapping,
                                                NULL,
                                                sequence, NULL, NULL, err)) {
    gt_str_delete(sequence);
    return gt_lua_error(L, err);
  }
  lua_pushstring(L, gt_str_get(sequence));
  gt_str_delete(sequence);
  gt_error_delete(err);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x6cf7a(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, 0x30(%rsp)
testq %rax, %rax
jne 0x884dd
leaq 0x6d063(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r13
movq %rbx, %rdi
movl $0x3, %esi
callq 0x573d2
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
leaq 0x6d1d9(%rip), %rdx     # 0xf56e4
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a67c
movq %rax, %r14
callq 0x34f04
movq %rax, %r15
callq 0x3b728
movq %rax, %r12
movq %r13, %rdi
callq 0x3cd3b
movq (%r14), %r9
movq %r15, 0x20(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movq $0x0, (%rsp)
movq 0x30(%rsp), %rdi
movq %rax, %rsi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa7705
testl %eax, %eax
je 0x88589
movq %r12, %rdi
callq 0x3c87b
movq %rbx, %rdi
movq %r15, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa7d4a
movq %r12, %rdi
callq 0x3bb5d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movq %r12, %rdi
callq 0x3c87b
movq %r15, %rdi
callq 0x35085
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq