LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x6ce55(%rip), %r14     # 0xf5427
movl $0x1, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r12
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r15
movq (%r12), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x8861a
leaq 0x6cf26(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq (%r15), %rdi
callq 0x40c37
movq %rax, %r15
testq %rax, %rax
jne 0x8863e
leaq 0x6cf02(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq %r15, %rdi
callq 0x408bb
testq %rax, %rax
je 0x8865f
leaq 0x6d0ad(%rip), %rdx     # 0xf56ff
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq %r14, %rdi
movq %r15, %rsi
callq 0x40957
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: 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 0x6cda1(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x48aa3
movq %rax, %r14
testq %rax, %rax
jne 0x886b4
leaq 0x6d067(%rip), %rdx     # 0xf570e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x48a93
movq %rbx, %rdi
testq %rax, %rax
je 0x886ce
movq %rax, %rsi
callq 0x5790a
jmp 0x886d3
callq 0x57704
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: 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 0x6cd39(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x48aa3
movq %rax, %r14
testq %rax, %rax
jne 0x8871c
leaq 0x6cfff(%rip), %rdx     # 0xf570e
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x48a7e
testq %rax, %rax
je 0x88741
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x20257
// File: /workspace/github_c_makefile_star2_O3/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 0x6ccd3(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x84a54
movq %rax, %r14
testq %rax, %rax
jne 0x88782
leaq 0x6cfc5(%rip), %rdx     # 0xf573a
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x84a3f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: 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 0x6cc77(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x4990a
movq %rax, %r14
testq %rax, %rax
jne 0x887de
leaq 0x6cf7c(%rip), %rdx     # 0xf574d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x498ce
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: sequence_node_lua_get_sequence
static int sequence_node_lua_get_sequence(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_sequence(sn));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6cc1b(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x4990a
movq %rax, %r14
testq %rax, %rax
jne 0x8883a
leaq 0x6cf20(%rip), %rdx     # 0xf574d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x498e2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: sequence_node_lua_get_sequence_length
static int sequence_node_lua_get_sequence_length(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_pushnumber(L, gt_sequence_node_get_sequence_length(sn));
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6cbbf(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x4990a
movq %rax, %r14
testq %rax, %rax
jne 0x88896
leaq 0x6cec4(%rip), %rdx     # 0xf574d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %r14, %rdi
callq 0x498f6
movq %rax, %xmm1
punpckldq 0x58bd5(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x58bdd(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_get_children_generic
static int feature_node_lua_get_children_generic(lua_State *L, bool direct)
{
  GtGenomeNode **gn;
  GtFeatureNode *fn;
  GtFeatureNodeIterator **it;
  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");
  it = (GtFeatureNodeIterator**) lua_newuserdata(L,
                                              sizeof (GtFeatureNodeIterator *));
  luaL_getmetatable(L, "GenomeTools.get_children");
  lua_setmetatable(L, -2);
  if (direct)
    *it = gt_feature_node_iterator_new_direct(fn);
  else
    *it = gt_feature_node_iterator_new(fn);
  gt_assert(*it);
  lua_pushcclosure(L, feature_node_lua_get_children_iter, 1);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x6cb40(%rip), %rdx     # 0xf5427
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x40c37
movq %rax, %r14
testq %rax, %rax
jne 0x88915
leaq 0x6cc2b(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
movq %rax, %r15
leaq 0x6cb13(%rip), %rdx     # 0xf543f
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movq %r14, %rdi
testb %bpl, %bpl
je 0x88955
callq 0x40fcd
jmp 0x8895a
callq 0x40ee0
movq %rax, (%r15)
testq %rax, %rax
je 0x88980
leaq 0x1c(%rip), %rsi        # 0x88985
movq %rbx, %rdi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x57d08
callq 0x20290
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_each_attribute_iter
static int feature_node_lua_each_attribute_iter(lua_State *L) {
  GtFeatureNodeLuaEachAttribInfo *info;
  info = *(GtFeatureNodeLuaEachAttribInfo**) lua_touserdata(L,
                                                           lua_upvalueindex(1));
  if (!info->attribs) return 0;
  if (info->cur_attr < gt_str_array_size(info->attribs)) {
    const char *attr, *val;
    attr = gt_str_array_get(info->attribs, info->cur_attr);
    gt_assert(attr);
    val = gt_feature_node_get_attribute(info->fn, attr);
    gt_assert(val);
    lua_pushstring(L, attr);
    lua_pushstring(L, val);
    info->cur_attr++;
    return 2;
  } else
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0xffffd8ed, %esi       # imm = 0xFFFFD8ED
callq 0x57668
movq (%rax), %r12
movq 0x8(%r12), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x88a3a
movq (%r12), %r14
callq 0x3cbed
cmpq %rax, %r14
jae 0x88a3a
movq (%r12), %rsi
movq 0x8(%r12), %rdi
callq 0x3ca6f
testq %rax, %rax
je 0x88a45
movq %rax, %r14
movq 0x10(%r12), %rdi
movq %rax, %rsi
callq 0x3eedc
testq %rax, %rax
je 0x88a4a
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5790a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5790a
incq (%r12)
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x20302
callq 0x202c9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_new
static int feature_node_lua_new(lua_State *L)
{
  GtGenomeNode **gf;
  GtUword startpos, endpos;
  GtStrand strand;
  const char *seqid, *type, *strand_str;
  size_t length;
  GtStr *seqid_str;
  gt_assert(L);
  /* get/check parameters */
  seqid = luaL_checkstring(L, 1);
  type = luaL_checkstring(L, 2);
  startpos = luaL_checklong(L, 3);
  endpos   = luaL_checklong(L, 4);
  luaL_argcheck(L, startpos > 0, 3, "must be > 0");
  luaL_argcheck(L, endpos > 0, 4, "must be > 0");
  luaL_argcheck(L, startpos <= endpos, 3, "must be <= endpos");
  strand_str = luaL_checklstring(L, 5, &length);
  luaL_argcheck(L, length == 1, 5, "strand string must have length 1");
  luaL_argcheck(L, (strand = gt_strand_get(strand_str[0])) !=
                    GT_NUM_OF_STRAND_TYPES, 5, "invalid strand");
  /* construct object */
  gf = lua_newuserdata(L, sizeof (GtGenomeNode*));
  seqid_str = gt_str_new_cstr(seqid);
  *gf = gt_feature_node_new(seqid_str, type, startpos, endpos, strand);
  gt_str_delete(seqid_str);
  gt_assert(*gf);
  luaL_getmetatable(L, GENOME_NODE_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x88bc4
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a844
movq %rax, %r13
testq %r12, %r12
jne 0x88ac5
leaq 0x6ccbe(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
testq %r13, %r13
jne 0x88ade
leaq 0x6cca5(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a2e1
cmpq %r13, %r12
jbe 0x88af7
leaq 0x6cc98(%rip), %rdx     # 0xf5782
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rdx
callq 0x5a5dd
movq %rax, %rbp
cmpq $0x1, (%r14)
je 0x88b29
leaq 0x6cc78(%rip), %rdx     # 0xf5794
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5a2e1
movsbl (%rbp), %edi
callq 0x3cc78
movl %eax, %ebp
cmpl $0x4, %eax
jne 0x88b4d
leaq 0x6cc75(%rip), %rdx     # 0xf57b5
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5a2e1
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
movq %rax, %r14
movq %r15, %rdi
callq 0x3b785
movq %rax, %r15
movq %rax, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x3f280
movq %rax, (%r14)
movq %r15, %rdi
callq 0x3c87b
cmpq $0x0, (%r14)
je 0x88bc9
leaq 0x6c891(%rip), %rdx     # 0xf5427
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20372
callq 0x2033b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: region_node_lua_new
static int region_node_lua_new(lua_State *L)
{
  GtGenomeNode **rn;
  GtUword startpos, endpos;
  const char *seqid;
  GtStr *seqid_str;
  gt_assert(L);
  /* get_check parameters */
  seqid = luaL_checkstring(L, 1);
  startpos = luaL_checklong(L, 2);
  endpos   = luaL_checklong(L, 3);
  luaL_argcheck(L, startpos > 0, 2, "must be > 0");
  luaL_argcheck(L, endpos > 0, 3, "must be > 0");
  luaL_argcheck(L, startpos <= endpos, 2, "must be <= endpos");
  /* construct object */
  rn = lua_newuserdata(L, sizeof (GtGenomeNode*));
  seqid_str = gt_str_new_cstr(seqid);
  *rn = gt_region_node_new(seqid_str, startpos, endpos);
  gt_str_delete(seqid_str);
  gt_assert(*rn);
  luaL_getmetatable(L, GENOME_NODE_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x88cc9
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %rax, %r12
testq %r15, %r15
jne 0x88c2b
leaq 0x6cb58(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
testq %r12, %r12
jne 0x88c44
leaq 0x6cb3f(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
cmpq %r12, %r15
jbe 0x88c5d
leaq 0x6cb32(%rip), %rdx     # 0xf5782
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
movq %rax, %r13
movq %r14, %rdi
callq 0x3b785
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x495f0
movq %rax, (%r13)
movq %r14, %rdi
callq 0x3c87b
cmpq $0x0, (%r13)
je 0x88cce
leaq 0x6c787(%rip), %rdx     # 0xf5427
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x203e0
callq 0x203a9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: meta_node_lua_new
static int meta_node_lua_new(lua_State *L)
{
  GtGenomeNode **mn;
  const char *directive = NULL, *data = NULL;
  gt_assert(L);
  /* get_check parameters */
  directive = luaL_checkstring(L, 1);
  if (!lua_isnil(L, 2))
    data = luaL_checkstring(L, 2);
  /* construct object */
  mn = lua_newuserdata(L, sizeof (GtGenomeNode*));
  gt_assert(directive);
  *mn = gt_meta_node_new(directive, data);
  gt_assert(*mn);
  luaL_getmetatable(L, GENOME_NODE_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88d77
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x56f9b
testl %eax, %eax
je 0x88d1c
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %r14, %r14
je 0x88d7c
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x489ee
movq %rax, (%r12)
testq %rax, %rax
je 0x88d81
leaq 0x6c6db(%rip), %rdx     # 0xf5427
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x20485
callq 0x2044e
callq 0x20417
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: comment_node_lua_new
static int comment_node_lua_new(lua_State *L)
{
  GtGenomeNode **cn;
  const char *comment;
  gt_assert(L);
  /* get_check parameters */
  comment = luaL_checkstring(L, 1);
  /* construct object */
  cn = lua_newuserdata(L, sizeof (GtGenomeNode*));
  *cn = gt_comment_node_new(comment);
  gt_assert(*cn);
  luaL_getmetatable(L, GENOME_NODE_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x88dee
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
movq %rax, %r15
movq %r14, %rdi
callq 0x849d0
movq %rax, (%r15)
testq %rax, %rax
je 0x88df3
leaq 0x6c65e(%rip), %rdx     # 0xf5427
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x204f5
callq 0x204bc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: sequence_node_lua_new
static int sequence_node_lua_new(lua_State *L)
{
  GtGenomeNode **sn;
  GtStr *seq_str;
  const char *desc, *seq;
  gt_assert(L);
  /* get_check parameters */
  desc = luaL_checkstring(L, 1);
  seq = luaL_checkstring(L, 2);
  /* construct object */
  sn = lua_newuserdata(L, sizeof (GtGenomeNode*));
  seq_str = gt_str_new_cstr(seq);
  *sn = gt_sequence_node_new(desc, seq_str);
  gt_assert(*sn);
  gt_str_delete(seq_str);
  luaL_getmetatable(L, GENOME_NODE_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88e96
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
movq %rax, %r12
movq %r14, %rdi
callq 0x3b785
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x49850
movq %rax, (%r12)
testq %rax, %rax
je 0x88e9b
movq %r14, %rdi
callq 0x3c87b
leaq 0x6c5bc(%rip), %rdx     # 0xf5427
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x20565
callq 0x2052c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/gt_lua.c
// Function: gt_lua_open_lib
int gt_lua_open_lib(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  gt_lua_open_core(L); /* open core */
  gt_lua_open_extended(L); /* open extended */
#ifndef WITHOUT_CAIRO
  gt_lua_open_annotationsketch(L); /* open annotationsketch */
#endif
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88ee2
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
movq %rbx, %rdi
callq 0x88eec
movq %rbx, %rdi
callq 0x88f58
movq %rbx, %rdi
callq 0xad278
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x88ee7
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x205d5
callq 0x2059e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/gtcore_lua.c
// Function: gt_lua_open_core
int gt_lua_open_core(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  gt_lua_open_alphabet(L);
  gt_lua_open_bittab(L);
  gt_lua_open_encseq(L);
  gt_lua_open_mathsupport(L);
  gt_lua_open_range(L);
  gt_lua_open_score_matrix(L);
  gt_lua_open_translate(L);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88f4e
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
movq %rbx, %rdi
callq 0xace90
movq %rbx, %rdi
callq 0xad2cc
movq %rbx, %rdi
callq 0xae00c
movq %rbx, %rdi
callq 0x88fe4
movq %rbx, %rdi
callq 0x89084
movq %rbx, %rdi
callq 0x89f10
movq %rbx, %rdi
callq 0x8a50c
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x88f53
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20643
callq 0x2060c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/gtext_lua.c
// Function: gt_lua_open_extended
int gt_lua_open_extended(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  gt_lua_open_cds_stream(L);
  gt_lua_open_csa_stream(L);
  gt_lua_open_feature_index(L);
  gt_lua_open_feature_node_iterator(L);
  gt_lua_open_feature_stream(L);
  gt_lua_open_feature_visitor(L);
  gt_lua_open_genome_node(L);
  gt_lua_open_genome_stream(L);
  gt_lua_open_genome_visitor(L);
  gt_lua_open_region_mapping(L);
  gt_lua_open_stream_evaluator(L);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x88fda
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
movq %rbx, %rdi
callq 0xad994
movq %rbx, %rdi
callq 0xadaa8
movq %rbx, %rdi
callq 0xafc0a
movq %rbx, %rdi
callq 0xb0424
movq %rbx, %rdi
callq 0xb064c
movq %rbx, %rdi
callq 0xb0730
movq %rbx, %rdi
callq 0x87214
movq %rbx, %rdi
callq 0xb0991
movq %rbx, %rdi
callq 0xb10b9
movq %rbx, %rdi
callq 0x8982a
movq %rbx, %rdi
callq 0x8a2c0
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x88fdf
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x206b1
callq 0x2067a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/mathsupport_lua.c
// Function: gt_lua_open_mathsupport
int gt_lua_open_mathsupport(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_register(L, "gt", mathsupport_lib_f);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x89031
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x77ffe(%rip), %rsi     # 0x100ffb
leaq 0xc6b7c(%rip), %rdx     # 0x14fb80
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x89036
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2071f
callq 0x206e8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: gt_lua_open_range
int gt_lua_open_range(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, RANGE_METATABLE);
  /* metatable.__index = metatable */
  lua_pushvalue(L, -1); /* duplicate the metatable */
  lua_setfield(L, -2, "__index");
  /* set its _tostring field */
  lua_pushstring(L, "__tostring");
  lua_pushcfunction(L, range_lua_tostring);
  lua_settable(L, -3);
  /* set its _eq field */
  lua_pushstring(L, "__eq");
  lua_pushcfunction(L, range_lua_eq);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, range_lib_m);
  gt_lua_export_metatable(L, RANGE_METATABLE);
  luaL_register(L, "gt", range_lib_f);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8917d
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x6c47f(%rip), %r14     # 0xf5521
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x65215(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x65592(%rip), %rsi     # 0xee667
movq %rbx, %rdi
callq 0x5790a
leaq 0xa3(%rip), %rsi        # 0x89187
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0x651ee(%rip), %rsi     # 0xee2f0
movq %rbx, %rdi
callq 0x5790a
leaq 0xcf(%rip), %rsi        # 0x891e0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0xc6a71(%rip), %rdx     # 0x14fba0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa7bb1
leaq 0x77eb0(%rip), %rsi     # 0x100ffb
leaq 0xc6ade(%rip), %rdx     # 0x14fc30
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x89182
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2078f
callq 0x20756
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: range_lua_tostring
static int range_lua_tostring(lua_State *L)
{
  GtRange *range;
  char buf[BUFSIZ];
  range = check_range(L, 1);
  (void) snprintf(buf, BUFSIZ, GT_WU "-" GT_WU, range->start, range->end);
  lua_pushstring(L, buf);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rdi, %rbx
leaq 0x6c386(%rip), %rdx     # 0xf5521
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rcx
movq 0x8(%rax), %r8
leaq 0x6c2ff(%rip), %rdx     # 0xf54b2
movq %rsp, %r14
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
xorl %eax, %eax
callq 0xba10
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5790a
movl $0x1, %eax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: range_lua_eq
static int range_lua_eq(lua_State *L)
{
  GtRange *range_a, *range_b;
  bool ret = false;
  range_a = check_range(L, 1);
  range_b = check_range(L, 2);
  if (gt_range_compare(range_a, range_b) == 0)
    ret = true;
  lua_pushboolean(L, ret);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6c332(%rip), %r14     # 0xf5521
movl $0x1, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5a67c
movq %r15, %rdi
movq %rax, %rsi
callq 0x7e09c
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: gt_lua_range_push
int gt_lua_range_push(lua_State *L, GtRange inrange)
{
  GtRange *outrange;
  gt_assert(L);
  outrange = lua_newuserdata(L, sizeof (GtRange));
  *outrange = inrange;
  luaL_getmetatable(L, RANGE_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x89285
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x10, %esi
callq 0x5924a
movq %r15, (%rax)
movq %r14, 0x8(%rax)
leaq 0x6c2c1(%rip), %rdx     # 0xf5521
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x207c8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: range_lua_overlap
static int range_lua_overlap(lua_State *L)
{
  GtRange *range_a, *range_b;
  range_a = check_range(L, 1);
  range_b = check_range(L, 2);
  lua_pushboolean(L, gt_range_overlap(range_a, range_b));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6c239(%rip), %r14     # 0xf5521
movl $0x1, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5a67c
movq %r15, %rdi
movq %rax, %rsi
callq 0x7e1b2
movzbl %al, %esi
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: range_lua_overlap_delta
static int range_lua_overlap_delta(lua_State *L)
{
  GtRange *range_a, *range_b;
  GtUword delta;
  range_a = check_range(L, 1);
  range_b = check_range(L, 2);
  delta = luaL_checklong(L, 3);
  lua_pushboolean(L, gt_range_overlap_delta(range_a, range_b, delta));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6c1e9(%rip), %r14     # 0xf5521
movl $0x1, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7e1df
movzbl %al, %esi
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: range_lua_join
static int range_lua_join(lua_State *L)
{
  GtRange *final_range, tmp_rng, *range_a, *range_b;
  range_a = check_range(L, 1);
  range_b = check_range(L, 2);
  final_range = lua_newuserdata(L, sizeof (GtRange));
  tmp_rng = gt_range_join(range_a, range_b);
  final_range->start = tmp_rng.start;
  final_range->end   = tmp_rng.end;
  luaL_getmetatable(L, RANGE_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x6c153(%rip), %r14     # 0xf5521
movl $0x1, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r12
movl $0x10, %esi
movq %rbx, %rdi
callq 0x5924a
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x7e2af
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %r14, %rdx
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: range_lua_contains
static int range_lua_contains(lua_State *L)
{
  GtRange *range_a, *range_b;
  range_a = check_range(L, 1);
  range_b = check_range(L, 2);
  lua_pushboolean(L, gt_range_contains(range_a, range_b));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6c0d2(%rip), %r14     # 0xf5521
movl $0x1, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5a67c
movq %r15, %rdi
movq %rax, %rsi
callq 0x7e261
movzbl %al, %esi
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: range_lua_within
static int range_lua_within(lua_State *L)
{
  GtRange *range;
  long point;
  range = check_range(L, 1);
  point = luaL_checklong(L, 2);
  luaL_argcheck(L, point > 0, 2, "must be > 0");
  lua_pushboolean(L, gt_range_within(range, point));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x6c082(%rip), %rdx     # 0xf5521
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
testq %rax, %rax
jg 0x894d5
leaq 0x6c2ae(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq %r14, %rdi
movq %r15, %rsi
callq 0x7e28e
movzbl %al, %esi
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: range_lua_new
static int range_lua_new(lua_State *L)
{
  GtUword startpos, endpos;
  GtRange *range;
  startpos = luaL_checklong(L, 1);
  endpos   = luaL_checklong(L, 2);
  luaL_argcheck(L, startpos > 0, 1, "must be > 0");
  luaL_argcheck(L, endpos > 0, 2, "must be > 0");
  luaL_argcheck(L, startpos <= endpos, 1, "must be <= endpos");
  range = lua_newuserdata(L, sizeof (GtRange));
  range->start = startpos;
  range->end   = endpos;
  luaL_getmetatable(L, RANGE_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5a844
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
testq %r14, %r14
jne 0x89534
leaq 0x6c24f(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
testq %r15, %r15
jne 0x8954d
leaq 0x6c236(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
cmpq %r15, %r14
jbe 0x89566
leaq 0x6c229(%rip), %rdx     # 0xf5782
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movl $0x10, %esi
movq %rbx, %rdi
callq 0x5924a
movq %r14, (%rax)
movq %r15, 0x8(%rax)
leaq 0x6bfa0(%rip), %rdx     # 0xf5521
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: ranges_lua_sort
static int ranges_lua_sort(lua_State *L)
{
  GtArray *ranges;
  ranges = range_table_to_array(L);
  gt_ranges_sort(ranges);
  push_range_array_as_table(L, ranges);
  gt_array_delete(ranges);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x89690
movq %rax, %rbx
movq %rax, %rdi
callq 0x7ea1b
testq %rbx, %rbx
je 0x89638
movq %rbx, %rdi
callq 0x6f310
testq %rax, %rax
je 0x89638
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58130
movq %rbx, %rdi
callq 0x6f310
testq %rax, %rax
je 0x89640
xorl %r12d, %r12d
leaq 0x1(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x5772d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6f037
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x89235
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58524
movq %rbx, %rdi
callq 0x6f310
movq %r15, %r12
cmpq %rax, %r15
jb 0x895ef
jmp 0x89640
movq %r14, %rdi
callq 0x57704
movq %rbx, %rdi
callq 0x6f768
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: ranges_lua_are_sorted
static int ranges_lua_are_sorted(lua_State *L)
{
  GtArray *ranges;
  bool are_sorted;
  ranges = range_table_to_array(L);
  are_sorted = gt_ranges_are_sorted(ranges);
  gt_array_delete(ranges);
  lua_pushboolean(L, are_sorted);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x89690
movq %rax, %r14
movq %rax, %rdi
callq 0x7ea99
movl %eax, %ebp
movq %r14, %rdi
callq 0x6f768
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/range_lua.c
// Function: range_table_to_array
static GtArray* range_table_to_array(lua_State *L)
{
  lua_Integer i = 1;
  GtArray *ranges;
  GtRange *range;
  GT_UNUSED const char *msg;
  bool error;
  /* make sure we got a table as first argument */
  luaL_checktype(L, 1, LUA_TTABLE);
  /* traverse table and save the ranges */
  ranges = gt_array_new(sizeof (GtRange));
  lua_pushinteger(L, i);
  lua_gettable(L, 1);
  while (!lua_isnil(L, -1)) {
    error = false;
    range = lua_touserdata(L, -1);
    if (range && lua_getmetatable(L, -1)) {
      lua_getfield(L, LUA_REGISTRYINDEX, RANGE_METATABLE);
      if (lua_rawequal(L, -1, -2)) {
        lua_pop(L, 2); /* remove both metatables */
        gt_array_add(ranges, *range);
      }
      else
        error = true;
    }
    else
      error = true;
    if (error) {
      /* we have a non range in the table */
      msg = lua_pushfstring(L, "expected %s as type of table entry %d",
                            RANGE_METATABLE, i);
      gt_array_delete(ranges);
      lua_error(L);
    }
    i++;
    lua_pop(L, 1); /* pop last result */
    lua_pushinteger(L, i);
    lua_gettable(L, 1);
  }
  return ranges;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
movl $0x5, %edx
callq 0x5a731
movl $0x10, %edi
callq 0x6ef7c
movq %rax, %r14
movl $0x1, %r15d
movl $0x1, %esi
movq %rbx, %rdi
callq 0x5772d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x57e45
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
testl %eax, %eax
je 0x897c8
leaq 0x6c233(%rip), %r12     # 0xf5929
leaq 0x6be24(%rip), %r13     # 0xf5521
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57668
testq %rax, %rax
je 0x89768
movq %rax, %rbp
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58207
testl %eax, %eax
je 0x89768
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %r13, %rdx
callq 0x57f56
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x570ae
testl %eax, %eax
je 0x89768
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x56b09
movl $0x10, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x6f240
jmp 0x8978b
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x57c58
movq %r14, %rdi
callq 0x6f768
movq %rbx, %rdi
callq 0x58d50
incq %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5772d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x57e45
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f9b
testl %eax, %eax
jne 0x896fd
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: gt_lua_region_mapping_push
void gt_lua_region_mapping_push(lua_State *L, GtRegionMapping *rm)
{
  GtRegionMapping **rm_lua;
  gt_assert(L && rm);
  rm_lua = lua_newuserdata(L, sizeof (GtRegionMapping**));
  *rm_lua = rm;
  luaL_getmetatable(L, REGION_MAPPING_METATABLE);
  lua_setmetatable(L, -2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x89825
movq %rsi, %r14
testq %rsi, %rsi
je 0x89825
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
movq %r14, (%rax)
leaq 0x6bee0(%rip), %rdx     # 0xf56e4
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x586d6
callq 0x20801
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: gt_lua_open_region_mapping
int gt_lua_open_region_mapping(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, REGION_MAPPING_METATABLE);
  /* metatable.__index = metatable */
  lua_pushvalue(L, -1); /* duplicate the metatable */
  lua_setfield(L, -2, "__index");
  /* set its _gc field */
  lua_pushstring(L, "__gc");
  lua_pushcfunction(L, region_mapping_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, region_mapping_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", region_mapping_lib_f);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x898f6
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x6be9d(%rip), %rsi     # 0xf56e4
movq %rbx, %rdi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x64a73(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x643b3(%rip), %rsi     # 0xedc2a
movq %rbx, %rdi
callq 0x5790a
leaq 0x7a(%rip), %rsi        # 0x89900
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0xc63cc(%rip), %rdx     # 0x14fc70
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
leaq 0x77739(%rip), %rsi     # 0x100ffb
leaq 0xc63f7(%rip), %rdx     # 0x14fcc0
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x898fb
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20873
callq 0x2083a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_get_sequence_length
static int region_mapping_lua_get_sequence_length(lua_State *L)
{
  GtRegionMapping **region_mapping;
  GtError *err;
  GtStr *seqidstr;
  GtUword length;
  const char *seqid;
  int had_err = 0;
  gt_assert(L);
  region_mapping = check_region_mapping(L, 1);
  seqid = luaL_checkstring(L, 2);
  seqidstr = gt_str_new_cstr(seqid);
  err = gt_error_new();
  had_err = gt_region_mapping_get_sequence_length(*region_mapping, &length,
                                                  seqidstr, err);
  gt_str_delete(seqidstr);
  if (had_err)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  lua_pushnumber(L, length);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x899e0
movq %rdi, %r14
leaq 0x6bda8(%rip), %rdx     # 0xf56e4
movl $0x1, %ebx
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r12
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %rdi
callq 0x3b785
movq %rax, %r13
callq 0x34f04
movq %rax, %r15
movq (%r12), %rdi
movq %rsp, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0xa86e1
movl %eax, %ebp
movq %r13, %rdi
callq 0x3c87b
testl %ebp, %ebp
je 0x8999f
movq %r14, %rdi
movq %r15, %rsi
callq 0xa7d4a
movl %eax, %ebx
jmp 0x899cf
movq %r15, %rdi
callq 0x35085
movsd (%rsp), %xmm1
unpcklps 0x57acd(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x57ad5(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x57718
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x208ac
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_get_sequence
static int region_mapping_lua_get_sequence(lua_State *L)
{
  GtRegionMapping **region_mapping;
  GtError *err;
  GtStr *seqidstr;
  char *result;
  GtUword start, end;
  const char *seqid;
  int had_err = 0;
  gt_assert(L);
  region_mapping = check_region_mapping(L, 1);
  seqid = luaL_checkstring(L, 2);
  start = luaL_checknumber(L, 3);
  end = luaL_checknumber(L, 4);
  luaL_argcheck(L, start > 0, 3, "must be > 0");
  luaL_argcheck(L, end > 0, 4, "must be > 0");
  luaL_argcheck(L, start <= end, 3, "must be <= endpos");
  seqidstr = gt_str_new_cstr(seqid);
  err = gt_error_new();
  had_err = gt_region_mapping_get_sequence(*region_mapping, &result, seqidstr,
                                           start, end, err);
  gt_str_delete(seqidstr);
  if (had_err)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  lua_pushstring(L, result);
  gt_free(result);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x89b49
movq %rdi, %rbx
leaq 0x6bce1(%rip), %rdx     # 0xf56e4
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a7b9
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x60d1d(%rip), %xmm0    # 0xea760
cvttsd2si %xmm0, %r15
andq %rcx, %r15
orq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a7b9
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x60cf5(%rip), %xmm0    # 0xea760
cvttsd2si %xmm0, %r13
sarq $0x3f, %rcx
andq %rcx, %r13
orq %rax, %r13
testq %r15, %r15
jne 0x89a93
leaq 0x6bcf0(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
testq %r13, %r13
jne 0x89aac
leaq 0x6bcd7(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a2e1
cmpq %r13, %r15
jbe 0x89ac5
leaq 0x6bcca(%rip), %rdx     # 0xf5782
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
movq %r12, %rdi
callq 0x3b785
movq %rax, %rbp
callq 0x34f04
movq %rax, %r12
movq (%r14), %rdi
movq %rsp, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %r13, %r8
movq %rax, %r9
callq 0xa8075
movl %eax, %r14d
movq %rbp, %rdi
callq 0x3c87b
testl %r14d, %r14d
je 0x89b0c
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa7d4a
jmp 0x89b3a
movq %r12, %rdi
callq 0x35085
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x5790a
movq (%rsp), %rdi
leaq 0x6be47(%rip), %rsi     # 0xf5972
movl $0x8b, %edx
callq 0x35c27
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x208e3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_get_description
static int region_mapping_lua_get_description(lua_State *L)
{
  GtRegionMapping **region_mapping;
  GtError *err;
  GtStr *seqidstr, *descstr = NULL;
  const char *seqid;
  int had_err = 0;
  gt_assert(L);
  region_mapping = check_region_mapping(L, 1);
  seqid = luaL_checkstring(L, 2);
  seqidstr = gt_str_new_cstr(seqid);
  descstr = gt_str_new();
  err = gt_error_new();
  had_err = gt_region_mapping_get_description(*region_mapping, descstr,
                                              seqidstr, err);
  gt_str_delete(seqidstr);
  if (had_err)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  lua_pushstring(L, gt_str_get(descstr));
  gt_str_delete(descstr);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x89c13
movq %rdi, %rbx
leaq 0x6bb78(%rip), %rdx     # 0xf56e4
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r12
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %rdi
callq 0x3b785
movq %rax, %r13
callq 0x3b728
movq %rax, %r14
callq 0x34f04
movq %rax, %r15
movq (%r12), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0xa892f
movl %eax, %ebp
movq %r13, %rdi
callq 0x3c87b
testl %ebp, %ebp
je 0x89bdc
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa7d4a
movq %r15, %rdi
callq 0x35085
movq %r14, %rdi
callq 0x3bb5d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movq %r14, %rdi
callq 0x3c87b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2091a