LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x87589
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x875f8
leaq 0x66a6b(%rip), %rdi     # 0xedffb
xorl %eax, %eax
callq 0x35a32
movq %rbx, %rdi
movl $0x21, %esi
movq %r14, %rdx
callq 0xa4f6a
movl %eax, %ebp
testl %eax, %eax
je 0x875cf
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movzbl %al, %eax
cmpl $0xff, %eax
je 0x875ad
movq %rbx, %rdi
cmpl $0xd, %eax
je 0x875dd
callq 0xa4f03
testl %ebp, %ebp
jne 0x875ad
movq %rbx, %rdi
callq 0xa4eca
cmpb $0xa, %al
jne 0x875b4
jmp 0x875ee
callq 0xa4f03
movq %rbx, %rdi
callq 0xa4eca
cmpb $0xa, %al
jne 0x875ad
movq %rbx, %rdi
callq 0xa4f03
jmp 0x875ad
callq 0x200bc
// File: /workspace/github_c_makefile_star2_O1/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 0x87625
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x87735
testq %r15, %r15
je 0x87730
movq %r14, %rdi
callq 0xa4eca
movzbl %al, %eax
cmpb $0x3a, %al
ja 0x87679
movabsq $0x200002400, %rcx      # imm = 0x200002400
btq %rax, %rcx
jb 0x87680
movabsq $0x400000100000000, %rcx # imm = 0x400000100000000
btq %rax, %rcx
jae 0x87679
testb %bpl, %bpl
je 0x87680
movq %r14, %rdi
callq 0xa4f03
movsbl %al, %esi
movq %r15, %rdi
callq 0x3c28d
xorl %eax, %eax
jmp 0x876ec
cmpl $0xff, %eax
jne 0x87662
movq %r14, %rdi
callq 0xa4eca
movq %r14, %rdi
cmpb $-0x1, %al
je 0x876c0
callq 0xa4eca
cmpb $0xd, %al
je 0x876a4
movq %r14, %rdi
callq 0xa4eca
cmpb $0xa, %al
jne 0x876f5
movq %r14, %rdi
callq 0xa4f3d
movq %rax, %r15
movq %r14, %rdi
callq 0xa4f2d
leaq 0x6dbb0(%rip), %rsi     # 0xf526e
jmp 0x876d7
callq 0xa4f3d
movq %rax, %r15
movq %r14, %rdi
callq 0xa4f2d
leaq 0x6db6b(%rip), %rsi     # 0xf5242
movq %rbx, %rdi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0xa4f3d
movq %rax, %r15
movq %r14, %rdi
callq 0xa4f2d
movq %rax, %r12
movq %r14, %rdi
callq 0xa4eca
movsbl %al, %r8d
leaq 0x6db78(%rip), %rsi     # 0xf5296
movq %rbx, %rdi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3559f
jmp 0x876e7
callq 0x2012e
callq 0x200f5
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x6db5a(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq (%rax), %rdi
callq 0x415c0
movq (%r14), %rdi
testq %rax, %rax
je 0x879a7
callq 0x415c0
movq %rax, %r12
movq %rax, %rdi
callq 0x40276
movq %rax, %r15
movq (%r14), %rdi
callq 0x41f7e
movq %rax, %r13
movq (%r14), %rdi
callq 0x41fa1
movq %rax, %r14
movq %r12, %rdi
callq 0x3fdd2
movl %eax, %eax
leaq 0x5b1c0(%rip), %rcx     # 0xe2b44
movsbl (%rax,%rcx), %eax
movl %eax, (%rsp)
leaq 0x6db5e(%rip), %rdx     # 0xf54f0
leaq 0x10(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rcx
movq %r13, %r8
movq %r14, %r9
jmp 0x879e9
callq 0x4a358
testq %rax, %rax
je 0x879f0
movq (%r14), %rdi
callq 0x41f83
movq %rax, %r15
movq %rdx, %r12
movq (%r14), %rdi
callq 0x41f3f
movq %rax, %rdi
callq 0x3c40b
leaq 0x6db31(%rip), %rdx     # 0xf5507
leaq 0x10(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %rax, %rcx
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
callq 0xba10
leaq 0x67152(%rip), %rsi     # 0xeeb49
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x58880
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_O1/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 0x87a6f
movq %rdi, %rbx
leaq 0x6da57(%rip), %r14     # 0xf5487
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5b252
movq (%r15), %rcx
xorl %esi, %esi
cmpq (%rax), %rcx
sete %sil
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x201d9
// File: /workspace/github_c_makefile_star2_O1/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 0x582b2
movq (%rax), %rdi
testq %rdi, %rdi
je 0x87a8c
callq 0x41a94
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x582b2
movq (%rax), %rbx
testq %rbx, %rbx
je 0x87ac9
movq 0x8(%rbx), %rdi
callq 0x3d573
movq 0x10(%rbx), %rdi
callq 0x42ade
leaq 0x6d9af(%rip), %rsi     # 0xf546b
movq %rbx, %rdi
movl $0x1d9, %edx            # imm = 0x1D9
callq 0x362a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x87b16
movq %rsi, %r14
testq %rsi, %rsi
je 0x87b16
movq %rdi, %rbx
movl $0x8, %esi
callq 0x59e95
movq %r14, (%rax)
leaq 0x6d992(%rip), %rdx     # 0xf5487
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x59337
callq 0x20212
// File: /workspace/github_c_makefile_star2_O1/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 0x6d8d3(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
leaq 0x6d9b9(%rip), %rdx     # 0xf5581
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b252
movq (%r14), %rdi
movq %rax, %rsi
callq 0x41fe4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d892(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x41f3f
testq %rax, %rax
je 0x87c21
movq %rax, %rdi
callq 0x3c40b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
jmp 0x87c29
movq %rbx, %rdi
callq 0x5834e
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d849(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %rdi
callq 0x3c03d
movq %rax, %rbx
movq (%r14), %rdi
movq %rax, %rsi
callq 0x42013
movq %rbx, %rdi
callq 0x3d1eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d7f7(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x87cbe
leaq 0x6d8e2(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x3fdd2
movl %eax, %eax
leaq 0x5ae75(%rip), %rcx     # 0xe2b44
movb (%rax,%rcx), %al
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rbx, %rdi
callq 0x58568
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6d786(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x87d2f
leaq 0x6d871(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movq %rax, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x87d69
movsbl (%r15), %esi
leaq 0x5adea(%rip), %rdi     # 0xe2b44
movl $0x5, %edx
callq 0xb710
testq %rax, %rax
jne 0x87d7d
leaq 0x6d836(%rip), %rdx     # 0xf55a6
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movsbl (%r15), %edi
callq 0x3d5ec
movq %r14, %rdi
movl %eax, %esi
callq 0x405f2
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d6e1(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x87dd4
leaq 0x6d7cc(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x403a5
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d685(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x87e30
leaq 0x6d770(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %rdi
callq 0x3c03d
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x3f8b5
movq %rbx, %rdi
callq 0x3d1eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d612(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x87ea3
leaq 0x6d6fd(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x402b9
testb %al, %al
je 0x87ec5
movq %r14, %rdi
callq 0x405b4
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x58362
jmp 0x87ecd
movq %rbx, %rdi
callq 0x5834e
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d59f(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x87f16
leaq 0x6d68a(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b394
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x402cd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d540(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x87f75
leaq 0x6d62b(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x4062b
cltq
leaq 0x5ac6a(%rip), %rcx     # 0xe2bf0
movb (%rax,%rcx), %al
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rbx, %rdi
callq 0x58568
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6d4cf(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x87fe6
leaq 0x6d5ba(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movq %rax, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x88020
movsbl (%r15), %esi
leaq 0x5abdf(%rip), %rdi     # 0xe2bf0
movl $0x5, %edx
callq 0xb710
testq %rax, %rax
jne 0x88034
leaq 0x6d595(%rip), %rdx     # 0xf55bc
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movsbl (%r15), %edi
callq 0x3a5f0
movq %r14, %rdi
movl %eax, %esi
callq 0x3f918
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d429(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r14
movq (%r15), %rdi
callq 0x415c0
movq %rax, %r15
testq %rax, %rax
jne 0x880a1
leaq 0x6d4ff(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r15, %rdi
movq %r14, %rsi
callq 0x3f850
movq %rbx, %rdi
testq %rax, %rax
je 0x880be
movq %rax, %rsi
callq 0x58568
jmp 0x880c3
callq 0x5834e
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d3a7(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
movl $0x8, %edi
callq 0x6e93c
movq %rax, %r14
movq (%r15), %rdi
callq 0x415c0
movq %rax, %r15
testq %rax, %rax
jne 0x8811e
leaq 0x6d482(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r15, %rdi
movq %r14, %rsi
callq 0x40640
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58da0
movq %r14, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x881ad
xorl %r15d, %r15d
leaq 0x1(%r15), %r12
movq %r12, %xmm1
punpckldq 0x5932a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x59332(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x58362
movq %r14, %rdi
movq %r15, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x41ca0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x87acd
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x59193
movq %r14, %rdi
callq 0x6ecda
movq %r12, %r15
cmpq %rax, %r12
jb 0x88145
movq %r14, %rdi
callq 0x6f134
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d2af(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
leaq 0x6d3e6(%rip), %rdx     # 0xf55d2
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b252
movq %rax, %r12
callq 0x35584
movq %rax, %r14
movq (%r15), %rdi
movq (%r12), %rsi
movq %rax, %rdx
callq 0x42036
testl %eax, %eax
je 0x8822d
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa8706
movq %r14, %rdi
callq 0x35705
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d235(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x88280
leaq 0x6d320(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x3f850
testq %rax, %rax
je 0x882b6
leaq 0x6d344(%rip), %rdx     # 0xf55ed
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40b96
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d19d(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x88318
leaq 0x6d288(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x3f850
testq %rax, %rax
jne 0x8834e
leaq 0x6d2c6(%rip), %rdx     # 0xf5607
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq %r14, %rdi
movq %r15, %rsi
callq 0x40c42
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d114(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x883a1
leaq 0x6d1ff(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x883cc
leaq 0x6d266(%rip), %rdx     # 0xf5625
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r12
cmpb $0x0, (%r15)
jne 0x883f8
leaq 0x6d253(%rip), %rdx     # 0xf563e
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x40300
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6d061(%rip), %r14     # 0xf5487
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r15
movq (%r12), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x8846e
leaq 0x6d132(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq (%r15), %rdi
callq 0x415c0
movq %rax, %r15
testq %rax, %rax
jne 0x88492
leaq 0x6d10e(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x41f3f
movq %rax, %rdi
callq 0x3c40b
movq %rax, %r12
movq %r15, %rdi
callq 0x41f3f
movq %rax, %rdi
callq 0x3c40b
movq %r12, %rdi
movq %rax, %rsi
callq 0xb890
testl %eax, %eax
je 0x884d8
leaq 0x6d18e(%rip), %rdx     # 0xf5659
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq %r15, %rdi
callq 0x41ca0
movq %r14, %rdi
movq %rax, %rsi
callq 0x4005b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6cf26(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x3fcd9
movq %rax, %rdi
callq 0x4146c
movzbl %al, %esi
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ceec(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x885c9
leaq 0x6cfd7(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
xorl %esi, %esi
callq 0x85dd0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ce9c(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x88619
leaq 0x6cf87(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x40276
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6ce3f(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x88676
leaq 0x6cf2a(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
testq %rax, %rax
je 0x886b9
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x886a6
leaq 0x7ead3(%rip), %rdx     # 0x10716c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq %r14, %rdi
movq %r15, %rsi
callq 0x403c5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2024b
// File: /workspace/github_c_makefile_star2_O1/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 0x6cd96(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x88722
leaq 0x6ce7e(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
movq %rax, %r12
leaq 0x6cd7f(%rip), %rdx     # 0xf54b8
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
leaq 0x6cd11(%rip), %rdx     # 0xf546b
movl $0x1, %edi
movl $0x18, %esi
movl $0x1ea, %ecx            # imm = 0x1EA
callq 0x3601f
movq %rax, (%r12)
testq %rax, %rax
je 0x887c7
movq (%r15), %rdi
callq 0x41ca0
movq (%r12), %rcx
movq %rax, 0x10(%rcx)
movq (%r12), %rax
movq $0x0, (%rax)
movq %r14, %rdi
callq 0x3f860
movq (%r12), %rcx
movq %rax, 0x8(%rcx)
leaq 0x737(%rip), %rsi       # 0x88ee0
movq %rbx, %rdi
movl $0x1, %edx
callq 0x58930
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x20284
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x6cca8(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x8880d
leaq 0x6cd93(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
xorl %r12d, %r12d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %rdi
callq 0x3d6af
movq %rax, %r15
movq %r14, %rdi
callq 0x4186c
movq %rax, %r14
movq %rax, %rdi
callq 0x41a02
testq %rax, %rax
je 0x88898
movq %r14, %rdi
callq 0x41a02
testq %rax, %rax
je 0x88876
movq %rax, %rdi
callq 0x40276
movq %rax, %r13
cmpq %r15, %rax
je 0x8886c
movq %r14, %rdi
callq 0x41a02
testq %rax, %rax
jne 0x8884f
xorl %r12d, %r12d
cmpq %r15, %r13
sete %r12b
movq %r14, %rdi
callq 0x41a94
movq %rbx, %rdi
movl %r12d, %esi
callq 0x58a14
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x202bd
// File: /workspace/github_c_makefile_star2_O1/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 0x6cbd5(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq (%rax), %rdi
callq 0x415c0
testq %rax, %rax
jne 0x888e0
leaq 0x6ccc0(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, (%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5801c
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
leaq 0x6ce35(%rip), %rdx     # 0xf5744
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5b252
movq %rax, %r13
callq 0x35584
movq %rax, %r15
callq 0x3bfe0
movq %rax, %r12
movq (%r14), %r14
movq (%rsp), %rdi
callq 0x3d6af
movq %r12, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %r15
pushq (%r13)
callq 0xa7c30
addq $0x10, %rsp
testl %eax, %eax
je 0x88980
movq %r12, %rdi
callq 0x3d1eb
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa8706
movq %r12, %rdi
callq 0x3c40b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movq %r12, %rdi
callq 0x3d1eb
movq %r15, %rdi
callq 0x35705
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_O1/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 0x6cab8(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, 0x30(%rsp)
testq %rax, %rax
jne 0x889ff
leaq 0x6cba1(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r13
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5801c
xorl %ebp, %ebp
testl %eax, %eax
setne %bpl
leaq 0x6cd17(%rip), %rdx     # 0xf5744
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5b252
movq %rax, %r14
callq 0x35584
movq %rax, %r15
callq 0x3bfe0
movq %rax, %r12
movq %r13, %rdi
callq 0x3d6af
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 0xa80c1
testl %eax, %eax
je 0x88aab
movq %r12, %rdi
callq 0x3d1eb
movq %rbx, %rdi
movq %r15, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa8706
movq %r12, %rdi
callq 0x3c40b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movq %r12, %rdi
callq 0x3d1eb
movq %r15, %rdi
callq 0x35705
movl $0x1, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_remove_leaf
static int feature_node_lua_remove_leaf(lua_State *L)
{
  GtGenomeNode **parent, **leaf;
  GtFeatureNode *pf, *lf;
  parent = check_genome_node(L, 1);
  leaf  = check_genome_node(L, 2);
  pf = gt_feature_node_try_cast(*parent);
  luaL_argcheck(L, pf, 1, "not a feature node");
  lf = gt_feature_node_try_cast(*leaf);
  luaL_argcheck(L, lf, 2, "not a feature node");
  luaL_argcheck(L, gt_feature_node_number_of_children(lf) == 0, 2,
                "must be a leaf");
  gt_feature_node_remove_leaf(pf, lf);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6c993(%rip), %r14     # 0xf5487
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r15
movq (%r12), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x88b3c
leaq 0x6ca64(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq (%r15), %rdi
callq 0x415c0
movq %rax, %r15
testq %rax, %rax
jne 0x88b60
leaq 0x6ca40(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq %r15, %rdi
callq 0x41244
testq %rax, %rax
je 0x88b81
leaq 0x6cbeb(%rip), %rdx     # 0xf575f
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq %r14, %rdi
movq %r15, %rsi
callq 0x412e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: meta_node_lua_get_data
static int meta_node_lua_get_data(lua_State *L)
{
  GtGenomeNode **gn;
  GtMetaNode *mn;
  const char *meta_data = NULL;
  gn = check_genome_node(L, 1);
  /* make sure we get a meta node */
  mn = gt_meta_node_try_cast(*gn);
  luaL_argcheck(L, mn, 1, "not a meta node");
  meta_data = gt_meta_node_get_data(mn);
  if (meta_data) {
    lua_pushstring(L, meta_data);
  } else {
    lua_pushnil(L);
  }
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6c8df(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x49707
movq %rax, %r14
testq %rax, %rax
jne 0x88bd6
leaq 0x6cba5(%rip), %rdx     # 0xf576e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x496f7
movq %rbx, %rdi
testq %rax, %rax
je 0x88bf0
movq %rax, %rsi
callq 0x58568
jmp 0x88bf5
callq 0x5834e
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: meta_node_lua_get_directive
static int meta_node_lua_get_directive(lua_State *L)
{
  GtGenomeNode **gn;
  GtMetaNode *mn;
  const char *meta_directive = NULL;
  gn = check_genome_node(L, 1);
  /* make sure we get a meta node */
  mn = gt_meta_node_try_cast(*gn);
  luaL_argcheck(L, mn, 1, "not a meta node");
  meta_directive = gt_meta_node_get_directive(mn);
  gt_assert(meta_directive);
  lua_pushstring(L, meta_directive);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6c877(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x49707
movq %rax, %r14
testq %rax, %rax
jne 0x88c3e
leaq 0x6cb3d(%rip), %rdx     # 0xf576e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x496e2
testq %rax, %rax
je 0x88c63
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x202f6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: comment_node_lua_get_comment
static int comment_node_lua_get_comment(lua_State *L)
{
  GtGenomeNode **gn;
  GtCommentNode *cn;
  gn = check_genome_node(L, 1);
  /* make sure we get a meta node */
  cn = gt_comment_node_try_cast(*gn);
  luaL_argcheck(L, cn, 1, "not a comment node");
  lua_pushstring(L, gt_comment_node_get_comment(cn));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6c811(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x84ecc
movq %rax, %r14
testq %rax, %rax
jne 0x88ca4
leaq 0x6cb03(%rip), %rdx     # 0xf579a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x84eb7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: sequence_node_lua_get_description
static int sequence_node_lua_get_description(lua_State *L)
{
  GtGenomeNode **gn;
  GtSequenceNode *sn;
  gn = check_genome_node(L, 1);
  /* make sure we get a sequence node */
  sn = gt_sequence_node_try_cast(*gn);
  luaL_argcheck(L, sn, 1, "not a sequence node");
  lua_pushstring(L, gt_sequence_node_get_description(sn));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6c7b5(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x4a562
movq %rax, %r14
testq %rax, %rax
jne 0x88d00
leaq 0x6caba(%rip), %rdx     # 0xf57ad
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x4a526
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq