LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_use_symbolmap_file
static int encseq_encoder_lua_use_symbolmap_file(lua_State *L)
{
  GtEncseqEncoder **encoder;
  const char *smapfile;
  GtError *err;
  encoder = check_encseq_encoder(L, 1);
  smapfile = luaL_checkstring(L, 2);
  gt_assert(*encoder);
  err = gt_error_new();
  if (gt_encseq_encoder_use_symbolmap_file(*encoder, smapfile, err) != 0)
    gt_lua_error(L, err);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4e4ae(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
cmpq $0x0, (%r15)
je 0xaf243
movq %rax, %r12
callq 0x34f04
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xc84ae
testl %eax, %eax
je 0xaf22d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa7d4a
movq %r14, %rdi
callq 0x35085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x264ce
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_symbolmap_file
static int encseq_encoder_lua_symbolmap_file(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  lua_pushstring(L, gt_encseq_encoder_symbolmap_file(*encoder));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4e43e(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf27c
callq 0xc86b0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movl $0x1, %eax
popq %rbx
retq
callq 0x26507
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_enable_description_support
static int encseq_encoder_lua_enable_description_support(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  gt_encseq_encoder_enable_description_support(*encoder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e408(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf2a4
callq 0xc81d2
xorl %eax, %eax
popq %rcx
retq
callq 0x26540
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_disable_description_support
static int encseq_encoder_lua_disable_description_support(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  gt_encseq_encoder_disable_description_support(*encoder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e3e0(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf2cc
callq 0xc83c9
xorl %eax, %eax
popq %rcx
retq
callq 0x26579
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_enable_multiseq_support
static int encseq_encoder_lua_enable_multiseq_support(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  gt_encseq_encoder_enable_multiseq_support(*encoder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e3b8(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf2f4
callq 0xc81c2
xorl %eax, %eax
popq %rcx
retq
callq 0x265b2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_disable_multiseq_support
static int encseq_encoder_lua_disable_multiseq_support(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  gt_encseq_encoder_disable_multiseq_support(*encoder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e390(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf31c
callq 0xc83dc
xorl %eax, %eax
popq %rcx
retq
callq 0x265eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_enable_lossless_support
static int encseq_encoder_lua_enable_lossless_support(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  gt_encseq_encoder_enable_lossless_support(*encoder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e368(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf344
callq 0xc846d
xorl %eax, %eax
popq %rcx
retq
callq 0x26624
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_disable_lossless_support
static int encseq_encoder_lua_disable_lossless_support(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  gt_encseq_encoder_disable_lossless_support(*encoder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e340(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf36c
callq 0xc81f5
xorl %eax, %eax
popq %rcx
retq
callq 0x2665d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_set_input_dna
static int encseq_encoder_lua_set_input_dna(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  gt_encseq_encoder_set_input_dna(*encoder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e318(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf394
callq 0xc842b
xorl %eax, %eax
popq %rcx
retq
callq 0x26696
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_is_input_dna
static int encseq_encoder_lua_is_input_dna(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  lua_pushboolean(L, gt_encseq_encoder_is_input_dna(*encoder));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4e2ed(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf3cd
callq 0xc8664
movzbl %al, %esi
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
retq
callq 0x266cf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_set_input_protein
static int encseq_encoder_lua_set_input_protein(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  gt_encseq_encoder_set_input_protein(*encoder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e2b7(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf3f5
callq 0xc8441
xorl %eax, %eax
popq %rcx
retq
callq 0x26708
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_is_input_protein
static int encseq_encoder_lua_is_input_protein(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  lua_pushboolean(L, gt_encseq_encoder_is_input_protein(*encoder));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4e28c(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf42e
callq 0xc8673
movzbl %al, %esi
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
retq
callq 0x26741
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_encode
static int encseq_encoder_lua_encode(lua_State *L)
{
  GtEncseqEncoder **encoder;
  GtStrArray *seqfiles = gt_str_array_new();
  GtError *err;
  const char *indexname;
  encoder = check_encseq_encoder(L, 1);
  err = gt_error_new();
  if (gt_lua_get_table_as_strarray(L, 2, seqfiles, err) != 0) {
    gt_str_array_delete(seqfiles);
    gt_lua_error(L, err);
  }
  indexname = luaL_checkstring(L, 3);
  gt_assert(*encoder);
  if (gt_encseq_encoder_encode(*encoder, seqfiles, indexname, err) != 0) {
    gt_str_array_delete(seqfiles);
    gt_lua_error(L, err);
  }
  gt_str_array_delete(seqfiles);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x3c8cc
movq %rax, %rbx
leaq 0x4e244(%rip), %rdx     # 0xfd691
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r12
callq 0x34f04
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
movq %rbx, %rdx
movq %rax, %rcx
callq 0xa7c9b
testl %eax, %eax
je 0xaf48f
movq %rbx, %rdi
callq 0x3cc00
movq %r14, %rdi
movq %r15, %rsi
callq 0xa7d4a
movq %r14, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5a5dd
movq (%r12), %rdi
testq %rdi, %rdi
je 0xaf4ea
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xc86d4
testl %eax, %eax
je 0xaf4cc
movq %rbx, %rdi
callq 0x3cc00
movq %r14, %rdi
movq %r15, %rsi
callq 0xa7d4a
movq %rbx, %rdi
callq 0x3cc00
movq %r15, %rdi
callq 0x35085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2677a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_enable_autosupport
static int encseq_loader_lua_enable_autosupport(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_enable_autosupport(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e1b5(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf512
callq 0xca6b9
xorl %eax, %eax
popq %rcx
retq
callq 0x267b3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_disable_autosupport
static int encseq_loader_lua_disable_autosupport(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_disable_autosupport(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e18d(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf53a
callq 0xca753
xorl %eax, %eax
popq %rcx
retq
callq 0x267ec
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_require_description_support
static int encseq_loader_lua_require_description_support(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_require_description_support(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e165(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf562
callq 0xca84d
xorl %eax, %eax
popq %rcx
retq
callq 0x26825
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_drop_description_support
static int encseq_loader_lua_drop_description_support(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_drop_description_support(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e13d(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf58a
callq 0xca6a7
xorl %eax, %eax
popq %rcx
retq
callq 0x2685e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_require_multiseq_support
static int encseq_loader_lua_require_multiseq_support(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_require_multiseq_support(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e115(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf5b2
callq 0xca85f
xorl %eax, %eax
popq %rcx
retq
callq 0x26897
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_drop_multiseq_support
static int encseq_loader_lua_drop_multiseq_support(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_drop_multiseq_support(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e0ed(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf5da
callq 0xca698
xorl %eax, %eax
popq %rcx
retq
callq 0x268d0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_require_lossless_support
static int encseq_loader_lua_require_lossless_support(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_require_lossless_support(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e0c5(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf602
callq 0xca739
xorl %eax, %eax
popq %rcx
retq
callq 0x26909
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_drop_lossless_support
static int encseq_loader_lua_drop_lossless_support(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_drop_lossless_support(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e09d(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf62a
callq 0xca69d
xorl %eax, %eax
popq %rcx
retq
callq 0x26942
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_mirror
static int encseq_loader_lua_mirror(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_mirror(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e075(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf652
callq 0xca743
xorl %eax, %eax
popq %rcx
retq
callq 0x2697b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_do_not_mirror
static int encseq_loader_lua_do_not_mirror(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = check_encseq_loader(L, 1);
  gt_assert(*loader);
  gt_encseq_loader_do_not_mirror(*loader);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4e04d(%rip), %rdx     # 0xfd6ac
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf67a
callq 0xca6c9
xorl %eax, %eax
popq %rcx
retq
callq 0x269b4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_load
static int encseq_loader_lua_load(lua_State *L)
{
  GtEncseqLoader **loader;
  const char *indexname;
  GtError *err = gt_error_new();
  GtEncseq *encseq;
  loader = check_encseq_loader(L, 1);
  indexname = luaL_checkstring(L, 2);
  gt_assert(*loader);
  encseq = gt_encseq_loader_load(*loader, indexname, err);
  if (encseq == NULL)
    gt_lua_error(L, err);
  else {
    gt_lua_encseq_push(L, encseq);
  }
  gt_error_delete(err);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x34f04
movq %rax, %rbx
leaq 0x4e016(%rip), %rdx     # 0xfd6ac
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq (%r15), %rdi
testq %rdi, %rdi
je 0xaf6f5
movq %rax, %rsi
movq %rbx, %rdx
callq 0xc74f1
movq %r14, %rdi
testq %rax, %rax
je 0xaf6da
movq %rax, %rsi
callq 0xae48c
jmp 0xaf6e2
movq %rbx, %rsi
callq 0xa7d4a
movq %rbx, %rdi
callq 0x35085
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x269ed
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_builder_lua_enable_description_support
static int encseq_builder_lua_enable_description_support(lua_State *L)
{
  GtEncseqBuilder **builder;
  builder = check_encseq_builder(L, 1);
  gt_assert(*builder);
  gt_encseq_builder_enable_description_support(*builder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4dfc4(%rip), %rdx     # 0xfd6c6
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf71d
callq 0xcaa3e
xorl %eax, %eax
popq %rcx
retq
callq 0x26a26
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_builder_lua_disable_description_support
static int encseq_builder_lua_disable_description_support(lua_State *L)
{
  GtEncseqBuilder **builder;
  builder = check_encseq_builder(L, 1);
  gt_assert(*builder);
  gt_encseq_builder_disable_description_support(*builder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4df9c(%rip), %rdx     # 0xfd6c6
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf745
callq 0xcaa52
xorl %eax, %eax
popq %rcx
retq
callq 0x26a5f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_builder_lua_enable_multiseq_support
static int encseq_builder_lua_enable_multiseq_support(lua_State *L)
{
  GtEncseqBuilder **builder;
  builder = check_encseq_builder(L, 1);
  gt_assert(*builder);
  gt_encseq_builder_enable_multiseq_support(*builder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4df74(%rip), %rdx     # 0xfd6c6
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf76d
callq 0xcaa66
xorl %eax, %eax
popq %rcx
retq
callq 0x26a98
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_builder_lua_disable_multiseq_support
static int encseq_builder_lua_disable_multiseq_support(lua_State *L)
{
  GtEncseqBuilder **builder;
  builder = check_encseq_builder(L, 1);
  gt_assert(*builder);
  gt_encseq_builder_disable_multiseq_support(*builder);
  return 0;
}

// Assembly:
pushq %rax
leaq 0x4df4c(%rip), %rdx     # 0xfd6c6
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf795
callq 0xcaa76
xorl %eax, %eax
popq %rcx
retq
callq 0x26ad1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_builder_lua_add_str
static int encseq_builder_lua_add_str(lua_State *L)
{
  GtEncseqBuilder **builder;
  const char *str, *desc;
  builder = check_encseq_builder(L, 1);
  str = luaL_checkstring(L, 2);
  if (lua_isnil(L, 3))
    desc = "";
  else
    desc = luaL_checkstring(L, 3);
  gt_assert(*builder);
  gt_encseq_builder_add_cstr(*builder, str, strlen(str), desc);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x4df1d(%rip), %rdx     # 0xfd6c6
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %r15, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %rbx
movq %r15, %rdi
movl $0x3, %esi
callq 0x56f9b
testl %eax, %eax
je 0xaf7ed
movq %r15, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
jmp 0xaf7f4
leaq 0x3f343(%rip), %r15     # 0xeeb37
movq (%r14), %r14
testq %r14, %r14
je 0xaf81d
movq %rbx, %rdi
callq 0xb260
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xcaa86
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x26b0a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_builder_lua_add_encoded
static int encseq_builder_lua_add_encoded(lua_State *L)
{
  GtEncseqBuilder **builder;
  const char *desc;
  unsigned char *arr = NULL;
  GtUword arrlen = 0;
  GtError *err;
  builder = check_encseq_builder(L, 1);
  err = gt_error_new();
  if (gt_lua_get_table_as_uchararray(L, 2, &arr, &arrlen, err) != 0) {
    gt_lua_error(L, err);
  }
  if (lua_isnil(L, 3))
    desc = "";
  else
    desc = luaL_checkstring(L, 3);
  gt_assert(*builder);
  gt_encseq_builder_add_encoded_own(*builder, arr, arrlen, desc);
  gt_free(arr);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x4de8f(%rip), %rdx     # 0xfd6c6
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
callq 0x34f04
movq %rax, %rbx
movq %r15, %rdi
movl $0x2, %esi
callq 0x56f9b
cmpl $0x5, %eax
jne 0xaf95b
movq %r15, %rdi
movl $0x2, %esi
callq 0x574c7
movq %rax, %r12
leaq 0x4ddba(%rip), %rsi     # 0xfd633
movq %rax, %rdi
movl $0x327, %edx            # imm = 0x327
callq 0x35862
movq %rax, %r13
testq %r12, %r12
je 0xaf9e9
movq %r15, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x58086
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56ff1
leaq 0x4e501(%rip), %rsi     # 0xfddb9
testl %eax, %eax
je 0xaf968
movq %r14, (%rsp)
movl $0x1, %r14d
xorl %ebp, %ebp
testl %ebp, %ebp
jne 0xaf8f5
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x573a3
cmpl $0x100, %eax            # imm = 0x100
jl 0xaf939
movq %rbx, %rdi
leaq 0x4e4ec(%rip), %rsi     # 0xfddda
xorl %eax, %eax
callq 0x34f1f
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
incq %r14
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %r12, %r14
ja 0xaf9fe
movq %r15, %rdi
movl $0x2, %esi
movl %r14d, %edx
callq 0x58086
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56ff1
testl %eax, %eax
jne 0xaf8cc
jmp 0xaf9ee
movb %al, -0x1(%r13,%r14)
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
incq %r14
xorl %ebp, %ebp
cmpq %r12, %r14
jbe 0xaf913
movq (%rsp), %r14
jmp 0xaf97d
leaq 0x4e43f(%rip), %rsi     # 0xfdda1
xorl %r12d, %r12d
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x34f1f
movq %r15, %rdi
movq %rbx, %rsi
callq 0xa7d4a
movq %r15, %rdi
movl $0x3, %esi
callq 0x56f9b
testl %eax, %eax
je 0xaf9a2
movq %r15, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %rcx
jmp 0xaf9a9
leaq 0x3f18e(%rip), %rcx     # 0xeeb37
movq (%r14), %rdi
testq %rdi, %rdi
je 0xafa07
movq %r13, %rsi
movq %r12, %rdx
callq 0xcb099
leaq 0x4dc70(%rip), %rsi     # 0xfd633
movq %r13, %rdi
movl $0x34e, %edx            # imm = 0x34E
callq 0x35c27
movq %rbx, %rdi
callq 0x35085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r12d, %r12d
jmp 0xaf97d
movq (%rsp), %r14
leaq 0x4e3c0(%rip), %rsi     # 0xfddb9
jmp 0xaf968
movq (%rsp), %r14
jmp 0xaf972
callq 0x26b43
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_builder_lua_build
static int encseq_builder_lua_build(lua_State *L)
{
  GtEncseqBuilder **builder;
  GtEncseq *encseq;
  GtError *err;
  builder = check_encseq_builder(L, 1);
  err = gt_error_new();
  encseq = gt_encseq_builder_build(*builder, err);
  if (encseq == NULL) {
    gt_lua_error(L, err);
  } else
    gt_lua_encseq_push(L, encseq);
  gt_error_delete(err);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4dcab(%rip), %rdx     # 0xfd6c6
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
callq 0x34f04
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0xcb203
movq %rbx, %rdi
testq %rax, %rax
je 0xafa4d
movq %rax, %rsi
callq 0xae48c
jmp 0xafa55
movq %r14, %rsi
callq 0xa7d4a
movq %r14, %rdi
callq 0x35085
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_new
static int encseq_encoder_lua_new(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = lua_newuserdata(L, sizeof (GtEncseqEncoder*));
  gt_assert(encoder);
  *encoder = gt_encseq_encoder_new();
  gt_assert(*encoder);
  luaL_getmetatable(L, ENCSEQ_ENCODER_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
testq %rax, %rax
je 0xafada
movq %rax, %r14
callq 0xc8165
movq %rax, (%r14)
testq %rax, %rax
je 0xafadf
leaq 0x4dbde(%rip), %rdx     # 0xfd691
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 %r14
retq
callq 0x26bb5
callq 0x26b7c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_loader_lua_new
static int encseq_loader_lua_new(lua_State *L)
{
  GtEncseqLoader **loader;
  loader = lua_newuserdata(L, sizeof (GtEncseqLoader*));
  gt_assert(loader);
  *loader = gt_encseq_loader_new();
  gt_assert(*loader);
  luaL_getmetatable(L, ENCSEQ_LOADER_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
testq %rax, %rax
je 0xafb38
movq %rax, %r14
callq 0xc7495
movq %rax, (%r14)
testq %rax, %rax
je 0xafb3d
leaq 0x4db9b(%rip), %rdx     # 0xfd6ac
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 %r14
retq
callq 0x26c27
callq 0x26bee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_builder_lua_new
static int encseq_builder_lua_new(lua_State *L)
{
  GtEncseqBuilder **builder;
  GtAlphabet **alpha;
  builder = lua_newuserdata(L, sizeof (GtEncseqBuilder*));
  alpha = check_alphabet(L, 1);
  gt_assert(builder && *alpha);
  *builder = gt_encseq_builder_new(*alpha);
  gt_assert(*builder);
  luaL_getmetatable(L, ENCSEQ_BUILDER_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
movq %rax, %r14
leaq 0x460b6(%rip), %rdx     # 0xf5c13
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a67c
testq %r14, %r14
je 0xafbb2
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafbb2
callq 0xca964
movq %rax, (%r14)
testq %rax, %rax
je 0xafbb7
leaq 0x4db3b(%rip), %rdx     # 0xfd6c6
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 %r14
retq
callq 0x26c99
callq 0x26c60
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: gt_lua_feature_index_push
void gt_lua_feature_index_push(lua_State *L, GtFeatureIndex *fi)
{
  GtFeatureIndex **fi_lua;
  gt_assert(L && fi);
  fi_lua = lua_newuserdata(L, sizeof (GtFeatureIndex**));
  *fi_lua = fi;
  luaL_getmetatable(L, FEATURE_INDEX_METATABLE);
  lua_setmetatable(L, -2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xafc05
movq %rsi, %r14
testq %rsi, %rsi
je 0xafc05
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
movq %r14, (%rax)
leaq 0x4d9dd(%rip), %rdx     # 0xfd5c1
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 0x26cd2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: gt_lua_open_feature_index
int gt_lua_open_feature_index(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, FEATURE_INDEX_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, feature_index_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, feature_index_lib_m);
  gt_lua_export_metatable(L, FEATURE_INDEX_METATABLE);
  luaL_register(L, "gt", feature_index_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 0xafcd6
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x4d999(%rip), %r14     # 0xfd5c1
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x3e68f(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x3dfcf(%rip), %rsi     # 0xedc2a
movq %rbx, %rdi
callq 0x5790a
leaq 0x76(%rip), %rsi        # 0xafce0
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0xa09e8(%rip), %rdx     # 0x150670
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa7bb1
leaq 0x51357(%rip), %rsi     # 0x100ffb
leaq 0xa0a65(%rip), %rdx     # 0x150710
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0xafcdb
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x26d44
callq 0x26d0b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_lua_add_region_node
static int feature_index_lua_add_region_node(lua_State *L)
{
  GtFeatureIndex **fi;
  GtGenomeNode **gn;
  GtRegionNode *rn;
  GtError *err;
  gt_assert(L);
  fi = check_feature_index(L, 1);
  gn = check_genome_node(L, 2);
  rn = gt_region_node_try_cast(*gn);
  luaL_argcheck(L, rn, 2, "not a region node");
  err = gt_error_new();
  if (gt_feature_index_add_region_node(*fi, rn, err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xafda4
movq %rdi, %rbx
leaq 0x4d8a8(%rip), %rdx     # 0xfd5c1
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
leaq 0x456fa(%rip), %rdx     # 0xf5427
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x49700
movq %rax, %r15
testq %rax, %rax
jne 0xafd5e
leaq 0x4e1a7(%rip), %rdx     # 0xfdef8
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
callq 0x34f04
movq %rax, %r12
movq (%r14), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3d73d
testl %eax, %eax
je 0xafd8e
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa7d4a
movq %r12, %rdi
callq 0x35085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x26d7d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_lua_add_feature_node
static int feature_index_lua_add_feature_node(lua_State *L)
{
  GtFeatureIndex **fi;
  GtGenomeNode **gn;
  GtFeatureNode *fn;
  GtStr *seqid;
  GtError *err;
  bool has_seqid;
  gt_assert(L);
  fi = check_feature_index(L, 1);
  gn = check_genome_node(L, 2);
  fn = gt_feature_node_cast(*gn);
  luaL_argcheck(L, fn, 2, "not a feature node");
  seqid = gt_genome_node_get_seqid(*gn);
  luaL_argcheck(L, seqid, 2, "feature does not have a sequence id");
  err = gt_error_new();
  if (gt_feature_index_has_seqid(*fi, &has_seqid, gt_str_get(seqid), err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  luaL_argcheck(L, has_seqid, 2,
                "feature index does not contain corresponding sequence region");
  err = gt_error_new();
  if (gt_feature_index_add_feature_node(*fi, fn, err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xafec1
movq %rdi, %rbx
leaq 0x4d7fa(%rip), %rdx     # 0xfd5c1
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
leaq 0x4564c(%rip), %rdx     # 0xf5427
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a67c
movq %rax, %r12
movq (%rax), %rdi
callq 0x3f369
movq %rax, %r15
testq %rax, %rax
jne 0xafe0f
leaq 0x45731(%rip), %rdx     # 0xf5533
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r12), %rdi
callq 0x415a1
movq %rax, %r13
testq %rax, %rax
jne 0xafe34
leaq 0x4e106(%rip), %rdx     # 0xfdf2d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
callq 0x34f04
movq %rax, %r12
movq (%r14), %rbp
movq %r13, %rdi
callq 0x3bb5d
leaq 0x7(%rsp), %rsi
movq %rbp, %rdi
movq %rax, %rdx
movq %r12, %rcx
callq 0x3dc9a
testl %eax, %eax
jne 0xafe9b
movq %r12, %rdi
callq 0x35085
cmpb $0x0, 0x7(%rsp)
jne 0xafe81
leaq 0x4e0dd(%rip), %rdx     # 0xfdf51
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
callq 0x34f04
movq %rax, %r12
movq (%r14), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3d79a
testl %eax, %eax
je 0xafeb5
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa7d4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x35085
xorl %eax, %eax
jmp 0xafea6
callq 0x26db4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_lua_add_gff3file
static int feature_index_lua_add_gff3file(lua_State *L)
{
  GtFeatureIndex **fi;
  const char *filename;
  GtError *err;
  gt_assert(L);
  fi = check_feature_index(L, 1);
  filename = luaL_checkstring(L, 2);
  err = gt_error_new();
  if (gt_feature_index_add_gff3file(*fi, filename, err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xaff42
movq %rdi, %rbx
leaq 0x4d6e4(%rip), %rdx     # 0xfd5c1
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r12
callq 0x34f04
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3d854
testl %eax, %eax
je 0xaff2c
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa7d4a
movq %r14, %rdi
callq 0x35085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x26deb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_lua_get_features_for_seqid
static int feature_index_lua_get_features_for_seqid(lua_State *L)
{
  GtFeatureIndex **feature_index;
  const char *seqid;
  GtArray *features;
  GtError *err;
  feature_index = check_feature_index(L, 1);
  seqid = luaL_checkstring(L, 2);
  err = gt_error_new();
  features = gt_feature_index_get_features_for_seqid(*feature_index, seqid,
                                                     err);
  if (!features)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  push_features_as_table(L, features);
  gt_array_delete(features);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4d668(%rip), %rdx     # 0xfd5c1
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r12
callq 0x34f04
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3d9c8
testq %rax, %rax
je 0xaffc2
movq %rax, %r15
movq %r14, %rdi
callq 0x35085
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb0326
movq %r15, %rdi
callq 0x6f768
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa7d4a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_lua_get_features_for_range
static int feature_index_lua_get_features_for_range(lua_State *L)
{
  GtFeatureIndex **feature_index;
  const char *seqid;
  GtRange *range;
  GtError *err;
  bool has_seqid;
  GtArray *features;
  GT_UNUSED int had_err;

  feature_index = check_feature_index(L, 1);
  seqid = luaL_checkstring(L, 2);
  err = gt_error_new();
  if (gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  luaL_argcheck(L, has_seqid, 2,
                "feature_index does not contain seqid");
  range = check_range(L, 3);
  features = gt_array_new(sizeof (GtGenomeNode*));
  err = gt_error_new();
  had_err = gt_feature_index_get_features_for_range(*feature_index, features,
                                                    seqid, range, err);
  if (had_err)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  push_features_as_table(L, features);
  gt_array_delete(features);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4d5d4(%rip), %rdx     # 0xfd5c1
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
callq 0x34f04
movq %rax, %r12
movq (%r14), %rdi
leaq 0x7(%rsp), %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x3dc9a
testl %eax, %eax
je 0xb0033
movq %rbx, %rdi
movq %r12, %rsi
jmp 0xb00a0
movq %r12, %rdi
callq 0x35085
cmpb $0x0, 0x7(%rsp)
jne 0xb0056
leaq 0x4df64(%rip), %rdx     # 0xfdfad
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
leaq 0x454c4(%rip), %rdx     # 0xf5521
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a67c
movq %rax, %rbp
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %r12
callq 0x34f04
movq %rax, %r13
movq (%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movq %rax, %r8
callq 0x3da20
testl %eax, %eax
je 0xb00b4
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa7d4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x35085
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb0326
movq %r12, %rdi
callq 0x6f768
movl $0x1, %eax
jmp 0xb00a5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_lua_get_first_seqid
static int feature_index_lua_get_first_seqid(lua_State *L)
{
  GtFeatureIndex **feature_index;
  char *seqid;
  GtError *err;
  feature_index = check_feature_index(L, 1);
  err = gt_error_new();
  seqid = gt_feature_index_get_first_seqid(*feature_index, err);
  if (gt_error_is_set(err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  if (seqid) {
    lua_pushstring(L, seqid);
    gt_free(seqid);
  } else
    lua_pushnil(L);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4d4dc(%rip), %rdx     # 0xfd5c1
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
callq 0x34f04
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x3dad9
movq %rax, %r14
movq %r15, %rdi
callq 0x34fea
testb %al, %al
je 0xb0124
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa7d4a
movq %r15, %rdi
callq 0x35085
movq %rbx, %rdi
testq %r14, %r14
je 0xb0152
movq %r14, %rsi
callq 0x5790a
leaq 0x4dd5b(%rip), %rsi     # 0xfde9e
movq %r14, %rdi
movl $0xb5, %edx
callq 0x35c27
jmp 0xb0157
callq 0x57704
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_lua_get_seqids
static int feature_index_lua_get_seqids(lua_State *L)
{
  GtFeatureIndex **feature_index;
  GtStrArray *seqids;
  GtError *err;
  feature_index = check_feature_index(L, 1);
  err = gt_error_new();
  seqids = gt_feature_index_get_seqids(*feature_index, err);
  if (!seqids)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  /* push table containing sequence ids onto the stack */
  gt_lua_push_strarray_as_table(L, seqids);
  gt_str_array_delete(seqids);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4d450(%rip), %rdx     # 0xfd5c1
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
callq 0x34f04
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0x3db7e
testq %rax, %rax
je 0xb01bf
movq %rax, %r15
movq %r14, %rdi
callq 0x35085
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa7c17
movq %r15, %rdi
callq 0x3cc00
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa7d4a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_lua_get_range_for_seqid
static int feature_index_lua_get_range_for_seqid(lua_State *L)
{
  GtFeatureIndex **feature_index;
  const char *seqid;
  GtError *err;
  GtRange range;
  bool has_seqid;
  feature_index = check_feature_index(L, 1);
  seqid = luaL_checkstring(L, 2);
  err = gt_error_new();
  if (gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  luaL_argcheck(L, has_seqid, 2,
                "feature_index does not contain seqid");
  err = gt_error_new();
  if (gt_feature_index_get_range_for_seqid(*feature_index, &range, seqid, err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  return gt_lua_range_push(L, range);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4d3dd(%rip), %rdx     # 0xfd5c1
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
callq 0x34f04
movq %rax, %r12
movq (%r14), %rdi
leaq 0x7(%rsp), %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x3dc9a
testl %eax, %eax
jne 0xb0264
movq %r12, %rdi
callq 0x35085
cmpb $0x0, 0x7(%rsp)
jne 0xb0245
leaq 0x4dd75(%rip), %rdx     # 0xfdfad
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
callq 0x34f04
movq %rax, %r12
movq (%r14), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x3dbcc
testl %eax, %eax
je 0xb027b
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa7d4a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x35085
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x89235
jmp 0xb026f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_lua_has_seqid
static int feature_index_lua_has_seqid(lua_State *L)
{
  GtFeatureIndex **feature_index;
  bool has_seqid;
  const char *seqid;
  GtError *err;
  int had_err = 0;
  feature_index = check_feature_index(L, 1);
  seqid = luaL_checkstring(L, 2);
  err = gt_error_new();
  had_err = gt_feature_index_has_seqid(*feature_index, &has_seqid, seqid, err);
  if (had_err)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  lua_pushboolean(L, has_seqid);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x4d313(%rip), %rdx     # 0xfd5c1
movl $0x1, %ebx
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r12
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r13
callq 0x34f04
movq %rax, %r15
movq (%r12), %rdi
leaq 0xf(%rsp), %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x3dc9a
testl %eax, %eax
je 0xb0301
movq %r14, %rdi
movq %r15, %rsi
callq 0xa7d4a
movl %eax, %ebx
jmp 0xb0316
movq %r15, %rdi
callq 0x35085
movzbl 0xf(%rsp), %esi
movq %r14, %rdi
callq 0x57df3
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: push_features_as_table
static void push_features_as_table(lua_State *L, GtArray *features)
{
  GtUword i;
  if (features && gt_array_size(features)) {
    /* push table containing feature references onto the stack */
    lua_newtable(L);
    for (i = 0; i < gt_array_size(features); i++) {
      lua_pushinteger(L, i+1); /* in Lua we index from 1 on */
      gt_lua_genome_node_push(L, gt_genome_node_ref(*(GtGenomeNode**)
                                                  gt_array_get(features, i)));
      lua_rawset(L, -3);
    }
  }
  else
    lua_pushnil(L);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0xb03bd
movq %rsi, %r14
movq %rsi, %rdi
callq 0x6f310
testq %rax, %rax
je 0xb03bd
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58130
movq %r14, %rdi
callq 0x6f310
testq %rax, %rax
je 0xb03b1
xorl %r12d, %r12d
leaq 0x1(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5772d
movq %r14, %rdi
movq %r12, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x4130c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x875a5
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58524
movq %r14, %rdi
callq 0x6f310
movq %r15, %r12
cmpq %rax, %r15
jb 0xb0366
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x57704
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_index_lua.c
// Function: feature_index_memory_lua_new
static int feature_index_memory_lua_new(lua_State *L)
{
  GtFeatureIndex **feature_index;
  feature_index = lua_newuserdata(L, sizeof (GtFeatureIndex*));
  gt_assert(feature_index);
  *feature_index = gt_feature_index_memory_new();
  luaL_getmetatable(L, FEATURE_INDEX_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
testq %rax, %rax
je 0xb041f
movq %rax, %r14
callq 0x3ec3d
movq %rax, (%r14)
leaq 0x4d1c9(%rip), %rdx     # 0xfd5c1
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 %r14
retq
callq 0x26e22
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_node_iterator_lua.c
// Function: gt_lua_open_feature_node_iterator
int gt_lua_open_feature_node_iterator(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, GENOME_NODE_ITERATOR_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, feature_node_iterator_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, feature_node_iterator_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", feature_node_iterator_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 0xb04f0
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x4dc0f(%rip), %rsi     # 0xfe050
movq %rbx, %rdi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x3de79(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x3d7b9(%rip), %rsi     # 0xedc2a
movq %rbx, %rdi
callq 0x5790a
leaq 0x7a(%rip), %rsi        # 0xb04fa
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0xa0292(%rip), %rdx     # 0x150730
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
leaq 0x50b3f(%rip), %rsi     # 0x100ffb
leaq 0xa028d(%rip), %rdx     # 0x150750
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0xb04f5
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x26e90
callq 0x26e59
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/feature_node_iterator_lua.c
// Function: feature_node_iterator_lua_next
static int feature_node_iterator_lua_next(lua_State *L)
{
  GtFeatureNodeIterator **fni;
  GtFeatureNode *fn;
  fni = check_gt_feature_node_iterator(L, 1);
  fn = gt_feature_node_iterator_next(*fni);
  if (fn)
    gt_lua_genome_node_push(L, gt_genome_node_ref((GtGenomeNode*) fn));
  else
    lua_pushnil(L);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4db2d(%rip), %rdx     # 0xfe050
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0x41076
testq %rax, %rax
je 0xb054f
movq %rax, %rdi
callq 0x4130c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x875a5
jmp 0xb0557
movq %rbx, %rdi
callq 0x57704
movl $0x1, %eax
popq %rbx
retq