LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/luaserialize.c
// Function: gt_lua_table_to_str
int gt_lua_table_to_str(lua_State *L, GtStr *out, int index, GtError *err)
{
  int had_err;
#ifndef NDEBUG
  int stack_size = lua_gettop(L);
#endif
  gt_error_check(err);
  gt_assert(L && out && lua_istable(L, index));
  had_err = parse_table(L, out, index, 1, err);
  gt_assert(lua_gettop(L) == stack_size); /* make sure the stack doesn't grow */
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
testq %r14, %r14
je 0x65988
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x65a25
testq %rbx, %rbx
je 0x659d1
testq %r12, %r12
je 0x659d1
movq %rbx, %rdi
movl %r15d, %esi
callq 0x37b59
cmpl $0x5, %eax
jne 0x659d1
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movq %r14, %r8
callq 0x65a5b
movl %eax, %r14d
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x659fb
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xc85e0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x64684(%rip), %rsi     # 0xca066
leaq 0x783d0(%rip), %rdx     # 0xdddb9
leaq 0x78399(%rip), %rcx     # 0xddd89
leaq 0x783a6(%rip), %r8      # 0xddd9d
pushq $0x76
jmp 0x65a4d
movq 0xc85b6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6465a(%rip), %rsi     # 0xca066
leaq 0x783c8(%rip), %rdx     # 0xddddb
leaq 0x7836f(%rip), %rcx     # 0xddd89
leaq 0x7837c(%rip), %r8      # 0xddd9d
pushq $0x78
jmp 0x65a4d
movq 0xc858c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x64630(%rip), %rsi     # 0xca066
leaq 0x64c1c(%rip), %rdx     # 0xca659
leaq 0x78345(%rip), %rcx     # 0xddd89
leaq 0x78352(%rip), %r8      # 0xddd9d
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/xrf_abbr_entry.c
// Function: gt_xrf_abbr_entry_new
GtXRFAbbrEntry* gt_xrf_abbr_entry_new(GtUword line,
                                      GtStr *filename)
{
  GtXRFAbbrEntry *abbr_entry = gt_malloc(sizeof *abbr_entry);
  abbr_entry->content = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                       (GtFree) gt_str_delete);
  abbr_entry->line = line;
  abbr_entry->filename = gt_str_ref(filename);
  return abbr_entry;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x77cd5(%rip), %rsi     # 0xde207
pushq $0x18
popq %rdi
pushq $0x21
popq %rdx
callq 0xccb0
movq %rax, %r15
leaq -0x591b8(%rip), %rsi    # 0xd38f
leaq -0x51273(%rip), %rdx    # 0x152db
pushq $0x1
popq %rdi
callq 0x55da4
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %rbx, %rdi
callq 0x146aa
movq %rax, 0x10(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/xrf_abbr_entry.c
// Function: gt_xrf_abbr_entry_delete
void gt_xrf_abbr_entry_delete(GtXRFAbbrEntry *abbr_entry)
{
  if (!abbr_entry) return;
  gt_str_delete(abbr_entry->filename);
  gt_hashmap_delete(abbr_entry->content);
  gt_free(abbr_entry);
}

// Assembly:
testq %rdi, %rdi
je 0x6659f
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x152db
movq (%rbx), %rdi
callq 0x563a7
leaq 0x77c74(%rip), %rsi     # 0xde207
pushq $0x2e
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x665fc
movq %rsi, %rbx
testq %rsi, %rsi
je 0x665fc
movq %rdx, %r15
testq %rdx, %rdx
je 0x665fc
movq %rdi, %r14
movq (%rdi), %rdi
movq %rbx, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x665d3
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x13da9
movq %rax, %r15
movq (%r14), %r14
movq %rbx, %rdi
callq 0x4f8ae
movq %r14, %rdi
movq %rax, %rsi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x55f31
movq 0xc79b5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x63a59(%rip), %rsi     # 0xca066
leaq 0x77c11(%rip), %rdx     # 0xde225
leaq 0x77c25(%rip), %rcx     # 0xde240
leaq 0x77be5(%rip), %r8      # 0xde207
pushq $0x35
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x66652
movq (%rdi), %rdi
callq 0x55ef6
testq %rax, %rax
je 0x6664e
movq %rax, %rdi
popq %rax
jmp 0x143d2
xorl %eax, %eax
popq %rcx
retq
movq 0xc795f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x63a03(%rip), %rsi     # 0xca066
leaq 0x77df6(%rip), %rdx     # 0xde460
leaq 0x77be5(%rip), %rcx     # 0xde256
leaq 0x77b8f(%rip), %r8      # 0xde207
pushq $0x40
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x670de
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x4b988
movq (%rbx), %rdi
cmpq %rax, %r14
jae 0x670be
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x66572
incq %r14
jmp 0x67099
callq 0x4c19d
leaq 0x771f5(%rip), %rsi     # 0xde2bf
movq %rbx, %rdi
movl $0x198, %edx            # imm = 0x198
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x670fc
movq %rdx, %rbx
movq (%rdi), %rdi
callq 0x4b48e
movq (%rax), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x66632
movq 0xc6eb5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x62f59(%rip), %rsi     # 0xca066
leaq 0x771e1(%rip), %rdx     # 0xde2f5
leaq 0x771ee(%rip), %rcx     # 0xde309
leaq 0x7719d(%rip), %r8      # 0xde2bf
movl $0x1a0, %r9d            # imm = 0x1A0
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x671e7
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x6727a
leaq 0x77210(%rip), %rdi     # 0xde3fe
xorl %eax, %eax
callq 0xc5d2
pushq $0x20
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x8483c
testl %eax, %eax
jne 0x67248
movq %rbx, %rdi
callq 0x846b1
cmpb $0xa, %al
je 0x6723b
movzbl %al, %eax
cmpl $0xd, %eax
je 0x6724d
cmpl $0xff, %eax
je 0x6723b
cmpl $0x21, %eax
jne 0x671f8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x672b2
movq %rbx, %rdi
callq 0x84717
xorl %r15d, %r15d
jmp 0x6726c
movl %eax, %r15d
jmp 0x6726c
movq %rbx, %rdi
callq 0x84717
movq %rbx, %rdi
callq 0x846b1
xorl %r15d, %r15d
cmpb $0xa, %al
jne 0x6726c
movq %rbx, %rdi
callq 0x84717
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xc6d37(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x62ddb(%rip), %rsi     # 0xca066
leaq 0x633c7(%rip), %rdx     # 0xca659
leaq 0x77143(%rip), %rcx     # 0xde3dc
leaq 0x7701f(%rip), %r8      # 0xde2bf
movl $0xca, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x672cd
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x67336
leaq 0x6fc87(%rip), %rdi     # 0xd6f5b
xorl %eax, %eax
callq 0xc5d2
pushq $0x21
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x8483c
movl %eax, %ebp
testl %eax, %eax
jne 0x6732f
jmp 0x67308
movzbl %al, %eax
cmpl $0xff, %eax
je 0x6732f
movq %rbx, %rdi
cmpl $0xd, %eax
je 0x67316
callq 0x84717
movq %rbx, %rdi
callq 0x846b1
cmpb $0xa, %al
jne 0x672f1
jmp 0x67327
callq 0x84717
movq %rbx, %rdi
callq 0x846b1
cmpb $0xa, %al
jne 0x6732f
movq %rbx, %rdi
callq 0x84717
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0xc6c7b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x62d1f(%rip), %rsi     # 0xca066
leaq 0x6330b(%rip), %rdx     # 0xca659
leaq 0x770af(%rip), %rcx     # 0xde404
leaq 0x76f63(%rip), %r8      # 0xde2bf
movl $0xb1, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x77020(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
movq (%rax), %rdi
callq 0x1b4e0
movq (%r14), %rdi
testq %rax, %rax
je 0x677df
callq 0x1b4e0
movq %rax, %r12
movq %rax, %rdi
callq 0x19528
movq %rax, %r15
movq (%r14), %rdi
callq 0x1c3bf
movq %rax, %r13
movq (%r14), %rdi
callq 0x1c415
movq %rax, %r14
movq %r12, %rdi
callq 0x18f89
movl %eax, %eax
leaq 0x64388(%rip), %rcx     # 0xcbb44
movsbl (%rax,%rcx), %eax
movl %eax, (%rsp)
leaq 0x77026(%rip), %rdx     # 0xde7f0
leaq 0x10(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %r15, %rcx
movq %r13, %r8
movq %r14, %r9
jmp 0x67821
callq 0x26c21
testq %rax, %rax
je 0x67828
movq (%r14), %rdi
callq 0x1c3c4
movq %rax, %r15
movq %rdx, %r12
movq (%r14), %rdi
callq 0x1c31a
movq %rax, %rdi
callq 0x143d2
leaq 0x76ff9(%rip), %rdx     # 0xde807
leaq 0x10(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
movq %rax, %rcx
movq %r15, %r8
movq %r12, %r9
xorl %eax, %eax
callq 0xba00
leaq 0x7027a(%rip), %rsi     # 0xd7aa9
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x38764
pushq $0x1
popq %rax
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x678a7
movq %rdi, %rbx
leaq 0x76f1f(%rip), %r14     # 0xde787
pushq $0x1
popq %rbp
movl %ebp, %esi
movq %r14, %rdx
callq 0x3ae77
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3ae77
movq (%r15), %rcx
xorl %esi, %esi
cmpq (%rax), %rcx
sete %sil
movq %rbx, %rdi
callq 0x388fa
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xc670a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x627ae(%rip), %rsi     # 0xca066
leaq 0x6f137(%rip), %rdx     # 0xd69f6
leaq 0x76f54(%rip), %rcx     # 0xde81a
leaq 0x76e9e(%rip), %r8      # 0xde76b
movl $0x337, %r9d            # imm = 0x337
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x381c6
movq (%rax), %rdi
testq %rdi, %rdi
je 0x678f5
callq 0x1bbe1
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x381c6
movq (%rax), %rbx
testq %rbx, %rbx
je 0x67930
movq 0x8(%rbx), %rdi
callq 0x1583a
movq 0x10(%rbx), %rdi
callq 0x1d1e3
leaq 0x76e48(%rip), %rsi     # 0xde76b
movq %rbx, %rdi
movl $0x1d9, %edx            # imm = 0x1D9
callq 0xd249
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x67979
movq %rsi, %r14
testq %rsi, %rsi
je 0x67979
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x39c01
movq %r14, (%rax)
leaq 0x76e2d(%rip), %rdx     # 0xde787
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3914f
movq 0xc6638(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x626dc(%rip), %rsi     # 0xca066
leaq 0x76e3f(%rip), %rdx     # 0xde7d0
leaq 0x76e40(%rip), %rcx     # 0xde7d8
leaq 0x76dcc(%rip), %r8      # 0xde76b
movl $0x3af, %r9d            # imm = 0x3AF
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x76d37(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
leaq 0x76e1f(%rip), %rdx     # 0xde881
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq (%r14), %rdi
movq %rax, %rsi
callq 0x1c48b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76cfa(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1c31a
testq %rax, %rax
je 0x67ab7
movq %rax, %rdi
callq 0x143d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38431
jmp 0x67abf
movq %rbx, %rdi
callq 0x3824a
pushq $0x1
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76cb5(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %rdi
callq 0x13da9
movq %rax, %rbx
movq (%r14), %rdi
movq %rax, %rsi
callq 0x1c516
movq %rbx, %rdi
callq 0x152db
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76c67(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x67b4a
leaq 0x76d54(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
callq 0x18f89
movl %eax, %eax
leaq 0x63fe9(%rip), %rcx     # 0xcbb44
movb (%rax,%rcx), %al
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rbx, %rdi
callq 0x38431
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76bfa(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %rbx
testq %rax, %rax
jne 0x67bb7
leaq 0x76ce7(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
movq %rax, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x67bf0
movb (%r15), %bpl
movsbl %bpl, %esi
leaq 0x63f61(%rip), %rdi     # 0xcbb44
pushq $0x5
popq %rdx
callq 0xb710
testq %rax, %rax
jne 0x67c05
leaq 0x76caf(%rip), %rdx     # 0xde8a6
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x3ab1c
movb (%r15), %bpl
movsbl %bpl, %edi
callq 0x158a4
movq %rbx, %rdi
movl %eax, %esi
callq 0x19d24
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76b54(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x67c5d
leaq 0x76c41(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
callq 0x197b1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38431
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76afe(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x67cb3
leaq 0x76beb(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %rdi
callq 0x13da9
movq %rax, %rbx
movq %r14, %rdi
movq %rax, %rsi
callq 0x188ae
movq %rbx, %rdi
callq 0x152db
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76a91(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x67d20
leaq 0x76b7e(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
callq 0x195ce
testb %al, %al
je 0x67d42
movq %r14, %rdi
callq 0x19c2e
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x3825b
jmp 0x67d4a
movq %rbx, %rdi
callq 0x3824a
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76a24(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x67d8d
leaq 0x76b11(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3af85
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x19615
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x769cb(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x67de6
leaq 0x76ab8(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
callq 0x19d90
cltq
leaq 0x63df9(%rip), %rcx     # 0xcbbf0
movb (%rax,%rcx), %al
leaq 0x6(%rsp), %rsi
movb %al, (%rsi)
movb $0x0, 0x1(%rsi)
movq %rbx, %rdi
callq 0x38431
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7695e(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %rbx
testq %rax, %rax
jne 0x67e53
leaq 0x76a4b(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
movq %rax, %rdi
callq 0xb260
cmpq $0x1, %rax
jne 0x67e8c
movb (%r15), %bpl
movsbl %bpl, %esi
leaq 0x63d71(%rip), %rdi     # 0xcbbf0
pushq $0x5
popq %rdx
callq 0xb710
testq %rax, %rax
jne 0x67ea1
leaq 0x76a29(%rip), %rdx     # 0xde8bc
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x3ab1c
movb (%r15), %bpl
movsbl %bpl, %edi
callq 0x121e8
movq %rbx, %rdi
movl %eax, %esi
callq 0x18944
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x768b7(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r14
movq (%r15), %rdi
callq 0x1b4e0
movq %rax, %r15
testq %rax, %rax
jne 0x67f0d
leaq 0x76991(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r15, %rdi
movq %r14, %rsi
callq 0x18818
movq %rbx, %rdi
testq %rax, %rax
je 0x67f2a
movq %rax, %rsi
callq 0x38431
jmp 0x67f2f
callq 0x3824a
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x7683d(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, %r14
movq (%r15), %rdi
callq 0x1b4e0
movq %rax, %r15
testq %rax, %rax
jne 0x67f82
leaq 0x7691c(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r15, %rdi
movq %r14, %rsi
callq 0x19dd8
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38be5
pushq $-0x3
popq %rbp
movq %r14, %rdi
callq 0x4b988
cmpq %rax, %r15
jae 0x68006
leaq 0x1(%r15), %r12
movq %r12, %xmm1
punpckldq 0x624c3(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x624cb(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
movq %r14, %rdi
movq %r15, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x1bec8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x67934
movq %rbx, %rdi
movl %ebp, %esi
callq 0x38f9d
movq %r12, %r15
jmp 0x67f9f
movq %r14, %rdi
callq 0x4c19d
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7675b(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
leaq 0x76894(%rip), %rdx     # 0xde8d2
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq %rax, %r12
callq 0xbff0
movq %rax, %r14
movq (%r15), %rdi
movq (%r12), %rsi
movq %rax, %rdx
callq 0x1c56c
testl %eax, %eax
je 0x6807d
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x88ba4
movq %r14, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x766e5(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x680cc
leaq 0x767d2(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x18818
testq %rax, %rax
je 0x680fe
leaq 0x767fa(%rip), %rdx     # 0xde8ed
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1a57d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76657(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x6815a
leaq 0x76744(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x18818
testq %rax, %rax
jne 0x6818c
leaq 0x76786(%rip), %rdx     # 0xde907
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a6b4
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x765d6(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x681db
leaq 0x766c3(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x68202
leaq 0x7672e(%rip), %rdx     # 0xde925
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r12
cmpb $0x0, (%r15)
jne 0x6822a
leaq 0x7671f(%rip), %rdx     # 0xde93e
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1967b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7652f(%rip), %r14     # 0xde787
pushq $0x1
popq %rsi
movq %r14, %rdx
callq 0x3ae77
movq %rax, %r12
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3ae77
movq %rax, %r15
movq (%r12), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x6829a
leaq 0x76604(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r15), %rdi
callq 0x1b4e0
movq %rax, %r15
testq %rax, %rax
jne 0x682bc
leaq 0x765e2(%rip), %rdx     # 0xde893
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
callq 0x1c31a
movq %rax, %rdi
callq 0x143d2
movq %rax, %r12
movq %r15, %rdi
callq 0x1c31a
movq %rax, %rdi
callq 0x143d2
movq %r12, %rdi
movq %rax, %rsi
callq 0xb880
testl %eax, %eax
je 0x68300
leaq 0x76664(%rip), %rdx     # 0xde959
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r15, %rdi
callq 0x1bec8
movq %r14, %rdi
movq %rax, %rsi
callq 0x19245
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x763fa(%rip), %rdx     # 0xde787
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x3ae77
movq (%rax), %rdi
callq 0x18df7
movq %rax, %rdi
callq 0x1b2b7
movzbl %al, %esi
movq %rbx, %rdi
callq 0x388fa
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x763be(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x683f3
leaq 0x764ab(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
xorl %esi, %esi
callq 0x6568c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x76372(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x6843f
leaq 0x7645f(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
callq 0x19528
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38431
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x7631b(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x68496
leaq 0x76408(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
testq %rax, %rax
je 0x684d5
movq %rax, %r15
cmpb $0x0, (%rax)
jne 0x684c2
leaq 0x87dad(%rip), %rdx     # 0xf0264
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq %r14, %rdi
movq %r15, %rsi
callq 0x19804
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0xc5adc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x61b80(%rip), %rsi     # 0xca066
leaq 0x656ce(%rip), %rdx     # 0xcdbbb
leaq 0x7649a(%rip), %rcx     # 0xde98e
leaq 0x76270(%rip), %r8      # 0xde76b
movl $0x22c, %r9d            # imm = 0x22C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x7624c(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r14
testq %rax, %rax
jne 0x68568
leaq 0x76336(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
movq %rax, %r12
leaq 0x7623b(%rip), %rdx     # 0xde7b8
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
leaq 0x761cf(%rip), %rdx     # 0xde76b
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
movl $0x1ea, %ecx            # imm = 0x1EA
callq 0xce9a
movq %rax, (%r12)
testq %rax, %rax
je 0x685fc
movq (%r15), %rdi
callq 0x1bec8
movq (%r12), %rcx
movq %rax, 0x10(%rcx)
movq (%r12), %rax
andq $0x0, (%rax)
movq %r14, %rdi
callq 0x18828
movq (%r12), %rcx
movq %rax, 0x8(%rcx)
leaq 0x790(%rip), %rsi       # 0x68d74
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x38814
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xc59b5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x61a59(%rip), %rsi     # 0xca066
leaq 0x763be(%rip), %rdx     # 0xde9d2
leaq 0x763bd(%rip), %rcx     # 0xde9d8
leaq 0x76149(%rip), %r8      # 0xde76b
movl $0x1eb, %r9d            # imm = 0x1EB
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x76142(%rip), %rdx     # 0xde787
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0x1b4e0
movq %rax, %r15
testq %rax, %rax
jne 0x6866f
leaq 0x7622f(%rip), %rdx     # 0xde893
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %rdi
callq 0x15a03
movq %rax, %r14
movq %r15, %rdi
callq 0x1b8e0
movq %rax, %r15
movq %rax, %rdi
callq 0x1bb1e
testq %rax, %rax
je 0x686ea
xorl %ebp, %ebp
testb $0x1, %bpl
jne 0x686c5
movq %r15, %rdi
callq 0x1bb1e
testq %rax, %rax
je 0x686c5
movq %rax, %rdi
callq 0x19528
cmpq %r14, %rax
sete %bpl
jmp 0x686a1
movq %r15, %rdi
callq 0x1bbe1
movzbl %bpl, %esi
andl $0x1, %esi
movq %rbx, %rdi
callq 0x388fa
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xc58c7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x6196b(%rip), %rsi     # 0xca066
leaq 0x7631b(%rip), %rdx     # 0xdea1d
leaq 0x76318(%rip), %rcx     # 0xdea21
leaq 0x7605b(%rip), %r8      # 0xde76b
movl $0x314, %r9d            # imm = 0x314
xorl %eax, %eax
callq 0xb8c0
callq 0xb300