LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x6c759(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x4a562
movq %rax, %r14
testq %rax, %rax
jne 0x88d5c
leaq 0x6ca5e(%rip), %rdx     # 0xf57ad
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x4a53a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: sequence_node_lua_get_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 0x6c6fd(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x4a562
movq %rax, %r14
testq %rax, %rax
jne 0x88db8
leaq 0x6ca02(%rip), %rdx     # 0xf57ad
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %r14, %rdi
callq 0x4a54e
movq %rax, %xmm1
punpckldq 0x586b3(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x586bb(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/genome_node_lua.c
// Function: feature_node_lua_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 0x6c67e(%rip), %rdx     # 0xf5487
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x415c0
movq %rax, %r14
testq %rax, %rax
jne 0x88e37
leaq 0x6c769(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
movq %rax, %r15
leaq 0x6c651(%rip), %rdx     # 0xf549f
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movq %r14, %rdi
testb %bpl, %bpl
je 0x88e77
callq 0x41959
jmp 0x88e7c
callq 0x4186c
movq %rax, (%r15)
testq %rax, %rax
je 0x88ea2
leaq 0x1c(%rip), %rsi        # 0x88ea7
movq %rbx, %rdi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x58930
callq 0x2032f
// File: /workspace/github_c_makefile_star2_O1/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 0x582b2
movq (%rax), %r12
movq 0x8(%r12), %rdi
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x88f5c
movq (%r12), %r14
callq 0x3d560
cmpq %rax, %r14
jae 0x88f5c
movq (%r12), %rsi
movq 0x8(%r12), %rdi
callq 0x3d3e2
testq %rax, %rax
je 0x88f67
movq %rax, %r14
movq 0x10(%r12), %rdi
movq %rax, %rsi
callq 0x3f850
testq %rax, %rax
je 0x88f6c
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58568
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58568
incq (%r12)
movl $0x2, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x203a1
callq 0x20368
// File: /workspace/github_c_makefile_star2_O1/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 0x890e6
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5b41f
movq %rax, %r13
testq %r12, %r12
jne 0x88fe7
leaq 0x6c7fc(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
testq %r13, %r13
jne 0x89000
leaq 0x6c7e3(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5aeac
cmpq %r13, %r12
jbe 0x89019
leaq 0x6c7d6(%rip), %rdx     # 0xf57e2
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movl $0x5, %esi
movq %r14, %rdx
callq 0x5b1b3
movq %rax, %rbp
cmpq $0x1, (%r14)
je 0x8904b
leaq 0x6c7b6(%rip), %rdx     # 0xf57f4
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5aeac
movsbl (%rbp), %edi
callq 0x3d5ec
movl %eax, %ebp
cmpl $0x4, %eax
jne 0x8906f
leaq 0x6c7b3(%rip), %rdx     # 0xf5815
movq %rbx, %rdi
movl $0x5, %esi
callq 0x5aeac
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
movq %rax, %r14
movq %r15, %rdi
callq 0x3c03d
movq %rax, %r15
movq %rax, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movl %ebp, %r8d
callq 0x3fbf0
movq %rax, (%r14)
movq %r15, %rdi
callq 0x3d1eb
cmpq $0x0, (%r14)
je 0x890eb
leaq 0x6c3cf(%rip), %rdx     # 0xf5487
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20411
callq 0x203da
// File: /workspace/github_c_makefile_star2_O1/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 0x891eb
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %rax, %r12
testq %r15, %r15
jne 0x8914d
leaq 0x6c696(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
testq %r12, %r12
jne 0x89166
leaq 0x6c67d(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
cmpq %r12, %r15
jbe 0x8917f
leaq 0x6c670(%rip), %rdx     # 0xf57e2
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
movq %rax, %r13
movq %r14, %rdi
callq 0x3c03d
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4a248
movq %rax, (%r13)
movq %r14, %rdi
callq 0x3d1eb
cmpq $0x0, (%r13)
je 0x891f0
leaq 0x6c2c5(%rip), %rdx     # 0xf5487
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2047f
callq 0x20448
// File: /workspace/github_c_makefile_star2_O1/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 0x89299
movq %rdi, %rbx
xorl %r15d, %r15d
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x57c5c
testl %eax, %eax
je 0x8923e
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %r14, %r14
je 0x8929e
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x49652
movq %rax, (%r12)
testq %rax, %rax
je 0x892a3
leaq 0x6c219(%rip), %rdx     # 0xf5487
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x20524
callq 0x204ed
callq 0x204b6
// File: /workspace/github_c_makefile_star2_O1/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 0x89310
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
movq %rax, %r15
movq %r14, %rdi
callq 0x84e48
movq %rax, (%r15)
testq %rax, %rax
je 0x89315
leaq 0x6c19c(%rip), %rdx     # 0xf5487
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x20594
callq 0x2055b
// File: /workspace/github_c_makefile_star2_O1/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 0x893b8
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
movq %rax, %r12
movq %r14, %rdi
callq 0x3c03d
movq %rax, %r14
movq %r15, %rdi
movq %rax, %rsi
callq 0x4a4a8
movq %rax, (%r12)
testq %rax, %rax
je 0x893bd
movq %r14, %rdi
callq 0x3d1eb
leaq 0x6c0fa(%rip), %rdx     # 0xf5487
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x20604
callq 0x205cb
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x89406
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
movq %rbx, %rdi
callq 0x89410
movq %rbx, %rdi
callq 0x8947c
movq %rbx, %rdi
callq 0xaddc4
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x8940b
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20674
callq 0x2063d
// File: /workspace/github_c_makefile_star2_O1/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 0x89472
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
movq %rbx, %rdi
callq 0xad9dc
movq %rbx, %rdi
callq 0xade18
movq %rbx, %rdi
callq 0xaeb50
movq %rbx, %rdi
callq 0x89508
movq %rbx, %rdi
callq 0x895a8
movq %rbx, %rdi
callq 0x8a434
movq %rbx, %rdi
callq 0x8aa28
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x89477
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x206e2
callq 0x206ab
// File: /workspace/github_c_makefile_star2_O1/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 0x894fe
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
movq %rbx, %rdi
callq 0xae4d0
movq %rbx, %rdi
callq 0xae5e4
movq %rbx, %rdi
callq 0xb074a
movq %rbx, %rdi
callq 0xb0f64
movq %rbx, %rdi
callq 0xb118c
movq %rbx, %rdi
callq 0xb1270
movq %rbx, %rdi
callq 0x8773c
movq %rbx, %rdi
callq 0xb14d1
movq %rbx, %rdi
callq 0xb1bf1
movq %rbx, %rdi
callq 0x89d4e
movq %rbx, %rdi
callq 0x8a7e4
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x89503
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20750
callq 0x20719
// File: /workspace/github_c_makefile_star2_O1/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 0x89555
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x77b66(%rip), %rsi     # 0x101087
leaq 0xc6658(%rip), %rdx     # 0x14fb80
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x8955a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x207be
callq 0x20787
// File: /workspace/github_c_makefile_star2_O1/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 0x896a1
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x6bfbb(%rip), %r14     # 0xf5581
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x64d39(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x650b6(%rip), %rsi     # 0xee6af
movq %rbx, %rdi
callq 0x58568
leaq 0xa3(%rip), %rsi        # 0x896ab
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0x64d12(%rip), %rsi     # 0xee338
movq %rbx, %rdi
callq 0x58568
leaq 0xcf(%rip), %rsi        # 0x89704
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0xc654d(%rip), %rdx     # 0x14fba0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa856d
leaq 0x77a18(%rip), %rsi     # 0x101087
leaq 0xc65ba(%rip), %rdx     # 0x14fc30
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x896a6
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2082e
callq 0x207f5
// File: /workspace/github_c_makefile_star2_O1/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 0x6bec2(%rip), %rdx     # 0xf5581
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rcx
movq 0x8(%rax), %r8
leaq 0x6be3b(%rip), %rdx     # 0xf5512
movq %rsp, %r14
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
xorl %eax, %eax
callq 0xba10
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58568
movl $0x1, %eax
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6be6e(%rip), %r14     # 0xf5581
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5b252
movq %r15, %rdi
movq %rax, %rsi
callq 0x7df58
xorl %esi, %esi
testl %eax, %eax
sete %sil
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x897a9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x10, %esi
callq 0x59e95
movq %r15, (%rax)
movq %r14, 0x8(%rax)
leaq 0x6bdfd(%rip), %rdx     # 0xf5581
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x20867
// File: /workspace/github_c_makefile_star2_O1/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 0x6bd75(%rip), %r14     # 0xf5581
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5b252
movq %r15, %rdi
movq %rax, %rsi
callq 0x7e06e
movzbl %al, %esi
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6bd25(%rip), %r14     # 0xf5581
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x7e09b
movzbl %al, %esi
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6bc8f(%rip), %r14     # 0xf5581
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r12
movl $0x10, %esi
movq %rbx, %rdi
callq 0x59e95
movq %rax, %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x7e16b
movq %rax, (%r13)
movq %rdx, 0x8(%r13)
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %r14, %rdx
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6bc0e(%rip), %r14     # 0xf5581
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5b252
movq %r15, %rdi
movq %rax, %rsi
callq 0x7e11d
movzbl %al, %esi
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6bbbe(%rip), %rdx     # 0xf5581
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
testq %rax, %rax
jg 0x899f9
leaq 0x6bdea(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq %r14, %rdi
movq %r15, %rsi
callq 0x7e14a
movzbl %al, %esi
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b41f
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
testq %r14, %r14
jne 0x89a58
leaq 0x6bd8b(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
testq %r15, %r15
jne 0x89a71
leaq 0x6bd72(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
cmpq %r15, %r14
jbe 0x89a8a
leaq 0x6bd65(%rip), %rdx     # 0xf57e2
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movl $0x10, %esi
movq %rbx, %rdi
callq 0x59e95
movq %r14, (%rax)
movq %r15, 0x8(%rax)
leaq 0x6badc(%rip), %rdx     # 0xf5581
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x89bb4
movq %rax, %rbx
movq %rax, %rdi
callq 0x7e92e
testq %rbx, %rbx
je 0x89b5c
movq %rbx, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x89b5c
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58da0
movq %rbx, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x89b64
xorl %r12d, %r12d
leaq 0x1(%r12), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x58377
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6e9fa
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x89759
movq %r14, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x59193
movq %rbx, %rdi
callq 0x6ecda
movq %r15, %r12
cmpq %rax, %r15
jb 0x89b13
jmp 0x89b64
movq %r14, %rdi
callq 0x5834e
movq %rbx, %rdi
callq 0x6f134
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/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 0x89bb4
movq %rax, %r14
movq %rax, %rdi
callq 0x7e9ac
movl %eax, %ebp
movq %r14, %rdi
callq 0x6f134
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b30c
movl $0x10, %edi
callq 0x6e93c
movq %rax, %r14
movl $0x1, %r15d
movl $0x1, %esi
movq %rbx, %rdi
callq 0x58377
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58a66
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
testl %eax, %eax
je 0x89cec
leaq 0x6bd6f(%rip), %r12     # 0xf5989
leaq 0x6b960(%rip), %r13     # 0xf5581
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x582b2
testq %rax, %rax
je 0x89c8c
movq %rax, %rbp
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x58e77
testl %eax, %eax
je 0x89c8c
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
movq %r13, %rdx
callq 0x58b98
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xfffffffe, %edx       # imm = 0xFFFFFFFE
callq 0x57d6f
testl %eax, %eax
je 0x89c8c
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x578d2
movl $0x10, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x6ec0e
jmp 0x89caf
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x58880
movq %r14, %rdi
callq 0x6f134
movq %rbx, %rdi
callq 0x5999c
incq %r15
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58377
movq %rbx, %rdi
movl $0x1, %esi
callq 0x58a66
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c5c
testl %eax, %eax
jne 0x89c21
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_O1/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 0x89d49
movq %rsi, %r14
testq %rsi, %rsi
je 0x89d49
movq %rdi, %rbx
movl $0x8, %esi
callq 0x59e95
movq %r14, (%rax)
leaq 0x6ba1c(%rip), %rdx     # 0xf5744
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x59337
callq 0x208a0
// File: /workspace/github_c_makefile_star2_O1/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 0x89e1a
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x6b9d9(%rip), %rsi     # 0xf5744
movq %rbx, %rdi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x64597(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x63ed7(%rip), %rsi     # 0xedc72
movq %rbx, %rdi
callq 0x58568
leaq 0x7a(%rip), %rsi        # 0x89e24
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0xc5ea8(%rip), %rdx     # 0x14fc70
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
leaq 0x772a1(%rip), %rsi     # 0x101087
leaq 0xc5ed3(%rip), %rdx     # 0x14fcc0
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x89e1f
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20912
callq 0x208d9
// File: /workspace/github_c_makefile_star2_O1/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 0x89f04
movq %rdi, %r14
leaq 0x6b8e4(%rip), %rdx     # 0xf5744
movl $0x1, %ebx
movl $0x1, %esi
callq 0x5b252
movq %rax, %r12
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %rdi
callq 0x3c03d
movq %rax, %r13
callq 0x35584
movq %rax, %r15
movq (%r12), %rdi
movq %rsp, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0xa9154
movl %eax, %ebp
movq %r13, %rdi
callq 0x3d1eb
testl %ebp, %ebp
je 0x89ec3
movq %r14, %rdi
movq %r15, %rsi
callq 0xa8706
movl %eax, %ebx
jmp 0x89ef3
movq %r15, %rdi
callq 0x35705
movsd (%rsp), %xmm1
unpcklps 0x575a9(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x575b1(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x58362
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2094b
// File: /workspace/github_c_makefile_star2_O1/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 0x8a06d
movq %rdi, %rbx
leaq 0x6b81d(%rip), %rdx     # 0xf5744
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b394
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x60849(%rip), %xmm0    # 0xea7b0
cvttsd2si %xmm0, %r15
andq %rcx, %r15
orq %rax, %r15
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5b394
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x60821(%rip), %xmm0    # 0xea7b0
cvttsd2si %xmm0, %r13
sarq $0x3f, %rcx
andq %rcx, %r13
orq %rax, %r13
testq %r15, %r15
jne 0x89fb7
leaq 0x6b82c(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
testq %r13, %r13
jne 0x89fd0
leaq 0x6b813(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5aeac
cmpq %r13, %r15
jbe 0x89fe9
leaq 0x6b806(%rip), %rdx     # 0xf57e2
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
movq %r12, %rdi
callq 0x3c03d
movq %rax, %rbp
callq 0x35584
movq %rax, %r12
movq (%r14), %rdi
movq %rsp, %rsi
movq %rbp, %rdx
movq %r15, %rcx
movq %r13, %r8
movq %rax, %r9
callq 0xa8a31
movl %eax, %r14d
movq %rbp, %rdi
callq 0x3d1eb
testl %r14d, %r14d
je 0x8a030
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa8706
jmp 0x8a05e
movq %r12, %rdi
callq 0x35705
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x58568
movq (%rsp), %rdi
leaq 0x6b983(%rip), %rsi     # 0xf59d2
movl $0x8b, %edx
callq 0x362a0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20982
// File: /workspace/github_c_makefile_star2_O1/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 0x8a137
movq %rdi, %rbx
leaq 0x6b6b4(%rip), %rdx     # 0xf5744
movl $0x1, %esi
callq 0x5b252
movq %rax, %r12
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %rdi
callq 0x3c03d
movq %rax, %r13
callq 0x3bfe0
movq %rax, %r14
callq 0x35584
movq %rax, %r15
movq (%r12), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0xa93c7
movl %eax, %ebp
movq %r13, %rdi
callq 0x3d1eb
testl %ebp, %ebp
je 0x8a100
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa8706
movq %r15, %rdi
callq 0x35705
movq %r14, %rdi
callq 0x3c40b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movq %r14, %rdi
callq 0x3d1eb
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x209b9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_get_md5_fingerprint
static int region_mapping_lua_get_md5_fingerprint(lua_State *L)
{
  GtRegionMapping **region_mapping;
  GtError *err;
  GtStr *seqidstr;
  GtRange *rng = NULL;
  GtUword offset;
  const char *md5 = NULL, *seqid;
  gt_assert(L);
  region_mapping = check_region_mapping(L, 1);
  seqid = luaL_checkstring(L, 2);
  if (lua_gettop(L) == 3)
    rng = check_range(L, 3);
  seqidstr = gt_str_new_cstr(seqid);
  err = gt_error_new();
  md5 = gt_region_mapping_get_md5_fingerprint(*region_mapping, seqidstr,
                                              rng, &offset, err);
  gt_str_delete(seqidstr);
  if (!md5)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  lua_pushstring(L, md5);
  lua_pushnumber(L, offset);
  return 2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x8a237
movq %rdi, %rbx
leaq 0x6b5e8(%rip), %rdx     # 0xf5744
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r12
movq %rbx, %rdi
callq 0x578c5
cmpl $0x3, %eax
jne 0x8a1a2
leaq 0x6b3ef(%rip), %rdx     # 0xf5581
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b252
movq %rax, %r15
movq %r12, %rdi
callq 0x3c03d
movq %rax, %r13
callq 0x35584
movq %rax, %r12
movq (%r14), %rdi
leaq 0x8(%rsp), %rcx
movq %r13, %rsi
movq %r15, %rdx
movq %rax, %r8
callq 0xa96b8
movq %rax, %r14
movq %r13, %rdi
callq 0x3d1eb
testq %r14, %r14
je 0x8a21e
movq %r12, %rdi
callq 0x35705
movq %rbx, %rdi
movq %r14, %rsi
callq 0x58568
movsd 0x8(%rsp), %xmm1
unpcklps 0x57285(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x5728d(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x2, %eax
jmp 0x8a229
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa8706
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x209f2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_new_seqfile_matchdesc
static int region_mapping_lua_new_seqfile_matchdesc(lua_State *L)
{
  const char *seqfilename;
  GtStrArray *seqfile;
  GtRegionMapping **region_mapping;
  gt_assert(L);
  seqfilename = luaL_checkstring(L, 1);
  region_mapping = lua_newuserdata(L, sizeof (GtRegionMapping*));
  gt_assert(region_mapping);
  seqfile = gt_str_array_new();
  gt_str_array_add_cstr(seqfile, seqfilename);
  /* XXX: make second and third parameter available */
  *region_mapping = gt_region_mapping_new_seqfiles(seqfile, true, false);
  gt_str_array_delete(seqfile);
  luaL_getmetatable(L, REGION_MAPPING_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8a2e0
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0x8a2e5
movq %rax, %r14
callq 0x3d23c
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x3d318
movq %r12, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xa88e1
movq %rax, (%r14)
movq %r12, %rdi
callq 0x3d573
leaq 0x6b48f(%rip), %rdx     # 0xf5744
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x20a62
callq 0x20a2b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_new_seqfile_matchdescstart
static int region_mapping_lua_new_seqfile_matchdescstart(lua_State *L)
{
  const char *seqfilename;
  GtStrArray *seqfile;
  GtRegionMapping **region_mapping;
  gt_assert(L);
  seqfilename = luaL_checkstring(L, 1);
  region_mapping = lua_newuserdata(L, sizeof (GtRegionMapping*));
  gt_assert(region_mapping);
  seqfile = gt_str_array_new();
  gt_str_array_add_cstr(seqfile, seqfilename);
  /* XXX: make second and third parameter available */
  *region_mapping = gt_region_mapping_new_seqfiles(seqfile, true, false);
  gt_region_mapping_enable_match_desc_start(*region_mapping);
  gt_str_array_delete(seqfile);
  luaL_getmetatable(L, REGION_MAPPING_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8a389
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0x8a38e
movq %rax, %r14
callq 0x3d23c
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x3d318
movq %r12, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xa88e1
movq %rax, (%r14)
movq %rax, %rdi
callq 0xa8a0f
movq %r12, %rdi
callq 0x3d573
leaq 0x6b3e6(%rip), %rdx     # 0xf5744
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x20ad0
callq 0x20a99