LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x4d9ca(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
cmpq $0x0, (%r15)
je 0xafd87
movq %rax, %r12
callq 0x35584
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xc7518
testl %eax, %eax
je 0xafd71
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa8706
movq %r14, %rdi
callq 0x35705
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2661e
// File: /workspace/github_c_makefile_star2_O1/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 0x4d95a(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafdc0
callq 0xc771a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movl $0x1, %eax
popq %rbx
retq
callq 0x26657
// File: /workspace/github_c_makefile_star2_O1/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 0x4d924(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafde8
callq 0xc723c
xorl %eax, %eax
popq %rcx
retq
callq 0x26690
// File: /workspace/github_c_makefile_star2_O1/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 0x4d8fc(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafe10
callq 0xc7433
xorl %eax, %eax
popq %rcx
retq
callq 0x266c9
// File: /workspace/github_c_makefile_star2_O1/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 0x4d8d4(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafe38
callq 0xc722c
xorl %eax, %eax
popq %rcx
retq
callq 0x26702
// File: /workspace/github_c_makefile_star2_O1/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 0x4d8ac(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafe60
callq 0xc7446
xorl %eax, %eax
popq %rcx
retq
callq 0x2673b
// File: /workspace/github_c_makefile_star2_O1/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 0x4d884(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafe88
callq 0xc74d7
xorl %eax, %eax
popq %rcx
retq
callq 0x26774
// File: /workspace/github_c_makefile_star2_O1/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 0x4d85c(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafeb0
callq 0xc725f
xorl %eax, %eax
popq %rcx
retq
callq 0x267ad
// File: /workspace/github_c_makefile_star2_O1/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 0x4d834(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafed8
callq 0xc7495
xorl %eax, %eax
popq %rcx
retq
callq 0x267e6
// File: /workspace/github_c_makefile_star2_O1/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 0x4d809(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaff11
callq 0xc76ce
movzbl %al, %esi
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
retq
callq 0x2681f
// File: /workspace/github_c_makefile_star2_O1/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 0x4d7d3(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaff39
callq 0xc74ab
xorl %eax, %eax
popq %rcx
retq
callq 0x26858
// File: /workspace/github_c_makefile_star2_O1/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 0x4d7a8(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaff72
callq 0xc76dd
movzbl %al, %esi
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
retq
callq 0x26891
// File: /workspace/github_c_makefile_star2_O1/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 0x3d23c
movq %rax, %rbx
leaq 0x4d760(%rip), %rdx     # 0xfd6f1
movq %r14, %rdi
movl $0x1, %esi
callq 0x5b252
movq %rax, %r12
callq 0x35584
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
movq %rbx, %rdx
movq %rax, %rcx
callq 0xa8657
testl %eax, %eax
je 0xaffd3
movq %rbx, %rdi
callq 0x3d573
movq %r14, %rdi
movq %r15, %rsi
callq 0xa8706
movq %r14, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5b1b3
movq (%r12), %rdi
testq %rdi, %rdi
je 0xb002e
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xc773e
testl %eax, %eax
je 0xb0010
movq %rbx, %rdi
callq 0x3d573
movq %r14, %rdi
movq %r15, %rsi
callq 0xa8706
movq %rbx, %rdi
callq 0x3d573
movq %r15, %rdi
callq 0x35705
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x268ca
// File: /workspace/github_c_makefile_star2_O1/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 0x4d6d1(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb0056
callq 0xc96b6
xorl %eax, %eax
popq %rcx
retq
callq 0x26903
// File: /workspace/github_c_makefile_star2_O1/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 0x4d6a9(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb007e
callq 0xc9750
xorl %eax, %eax
popq %rcx
retq
callq 0x2693c
// File: /workspace/github_c_makefile_star2_O1/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 0x4d681(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb00a6
callq 0xc984a
xorl %eax, %eax
popq %rcx
retq
callq 0x26975
// File: /workspace/github_c_makefile_star2_O1/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 0x4d659(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb00ce
callq 0xc96a4
xorl %eax, %eax
popq %rcx
retq
callq 0x269ae
// File: /workspace/github_c_makefile_star2_O1/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 0x4d631(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb00f6
callq 0xc985c
xorl %eax, %eax
popq %rcx
retq
callq 0x269e7
// File: /workspace/github_c_makefile_star2_O1/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 0x4d609(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb011e
callq 0xc9695
xorl %eax, %eax
popq %rcx
retq
callq 0x26a20
// File: /workspace/github_c_makefile_star2_O1/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 0x4d5e1(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb0146
callq 0xc9736
xorl %eax, %eax
popq %rcx
retq
callq 0x26a59
// File: /workspace/github_c_makefile_star2_O1/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 0x4d5b9(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb016e
callq 0xc969a
xorl %eax, %eax
popq %rcx
retq
callq 0x26a92
// File: /workspace/github_c_makefile_star2_O1/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 0x4d591(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb0196
callq 0xc9740
xorl %eax, %eax
popq %rcx
retq
callq 0x26acb
// File: /workspace/github_c_makefile_star2_O1/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 0x4d569(%rip), %rdx     # 0xfd70c
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb01be
callq 0xc96c6
xorl %eax, %eax
popq %rcx
retq
callq 0x26b04
// File: /workspace/github_c_makefile_star2_O1/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 0x35584
movq %rax, %rbx
leaq 0x4d532(%rip), %rdx     # 0xfd70c
movq %r14, %rdi
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq (%r15), %rdi
testq %rdi, %rdi
je 0xb0239
movq %rax, %rsi
movq %rbx, %rdx
callq 0xc64cf
movq %r14, %rdi
testq %rax, %rax
je 0xb021e
movq %rax, %rsi
callq 0xaefd0
jmp 0xb0226
movq %rbx, %rsi
callq 0xa8706
movq %rbx, %rdi
callq 0x35705
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x26b3d
// File: /workspace/github_c_makefile_star2_O1/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 0x4d4e0(%rip), %rdx     # 0xfd726
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb0261
callq 0xc9a43
xorl %eax, %eax
popq %rcx
retq
callq 0x26b76
// File: /workspace/github_c_makefile_star2_O1/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 0x4d4b8(%rip), %rdx     # 0xfd726
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb0289
callq 0xc9a57
xorl %eax, %eax
popq %rcx
retq
callq 0x26baf
// File: /workspace/github_c_makefile_star2_O1/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 0x4d490(%rip), %rdx     # 0xfd726
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb02b1
callq 0xc9a6b
xorl %eax, %eax
popq %rcx
retq
callq 0x26be8
// File: /workspace/github_c_makefile_star2_O1/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 0x4d468(%rip), %rdx     # 0xfd726
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb02d9
callq 0xc9a7b
xorl %eax, %eax
popq %rcx
retq
callq 0x26c21
// File: /workspace/github_c_makefile_star2_O1/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 0x4d439(%rip), %rdx     # 0xfd726
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %r15, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %rbx
movq %r15, %rdi
movl $0x3, %esi
callq 0x57c5c
testl %eax, %eax
je 0xb0331
movq %r15, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
jmp 0xb0338
leaq 0x3e847(%rip), %r15     # 0xeeb7f
movq (%r14), %r14
testq %r14, %r14
je 0xb0361
movq %rbx, %rdi
callq 0xb260
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xc9a8b
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x26c5a
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdi, %r15
leaq 0x4d3a8(%rip), %rdx     # 0xfd726
movl $0x1, %esi
callq 0x5b252
movq %rax, %r12
callq 0x35584
movq %rax, %r14
movq %r15, %rdi
movl $0x2, %esi
callq 0x57c5c
cmpl $0x5, %eax
jne 0xb0480
movq %r15, %rdi
movl $0x2, %esi
callq 0x58111
movq %rax, %r13
leaq 0x4d2d3(%rip), %rsi     # 0xfd693
movq %rax, %rdi
movl $0x327, %edx            # imm = 0x327
callq 0x35ee2
movq %rax, 0x8(%rsp)
testq %r13, %r13
je 0xb0495
movq %r12, 0x10(%rsp)
movq %r14, (%rsp)
xorl %r12d, %r12d
movl $0x1, %r14d
movq %r15, %rdi
movl $0x2, %esi
movl %r14d, %edx
callq 0x58cf6
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57cb2
testl %eax, %eax
je 0xb0499
testl %r12d, %r12d
je 0xb041b
xorl %ebx, %ebx
jmp 0xb0449
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57fed
movq %rax, %rbp
movb $0x1, %bl
cmpl $0x100, %ebp            # imm = 0x100
jl 0xb047b
xorl %ebx, %ebx
movq (%rsp), %rdi
leaq 0x4d9f8(%rip), %rsi     # 0xfde3a
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
testb %bl, %bl
je 0xb045d
movq 0x8(%rsp), %rax
movb %bpl, -0x1(%rax,%r14)
movq %r15, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
incq %r14
cmpq %r13, %r14
jbe 0xb03ed
jmp 0xb0536
xorl %r12d, %r12d
jmp 0xb044f
leaq 0x4d97a(%rip), %rsi     # 0xfde01
movq $0x0, 0x8(%rsp)
xorl %r13d, %r13d
jmp 0xb04a9
movb $0x1, %bl
jmp 0xb04b5
movq (%rsp), %r14
movq 0x10(%rsp), %r12
leaq 0x4d970(%rip), %rsi     # 0xfde19
xorl %ebx, %ebx
movq %r14, %rdi
xorl %eax, %eax
callq 0x3559f
testb %bl, %bl
jne 0xb04c4
movq %r15, %rdi
movq %r14, %rsi
callq 0xa8706
movq %r15, %rdi
movl $0x3, %esi
callq 0x57c5c
testl %eax, %eax
je 0xb04e9
movq %r15, %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %rcx
jmp 0xb04f0
leaq 0x3e68f(%rip), %rcx     # 0xeeb7f
movq (%r12), %rdi
testq %rdi, %rdi
je 0xb0544
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
movq %r13, %rdx
callq 0xca082
leaq 0x4d183(%rip), %rsi     # 0xfd693
movq %rbx, %rdi
movl $0x34e, %edx            # imm = 0x34E
callq 0x362a0
movq %r14, %rdi
callq 0x35705
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %r14
movq 0x10(%rsp), %r12
jmp 0xb04b5
callq 0x26c93
// File: /workspace/github_c_makefile_star2_O1/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 0x4d1ce(%rip), %rdx     # 0xfd726
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
callq 0x35584
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0xca20f
movq %rbx, %rdi
testq %rax, %rax
je 0xb058a
movq %rax, %rsi
callq 0xaefd0
jmp 0xb0592
movq %r14, %rsi
callq 0xa8706
movq %r14, %rdi
callq 0x35705
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x59e95
testq %rax, %rax
je 0xb0617
movq %rax, %r14
callq 0xc71cf
movq %rax, (%r14)
testq %rax, %rax
je 0xb061c
leaq 0x4d101(%rip), %rdx     # 0xfd6f1
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 %r14
retq
callq 0x26d05
callq 0x26ccc
// File: /workspace/github_c_makefile_star2_O1/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 0x59e95
testq %rax, %rax
je 0xb0675
movq %rax, %r14
callq 0xc6473
movq %rax, (%r14)
testq %rax, %rax
je 0xb067a
leaq 0x4d0be(%rip), %rdx     # 0xfd70c
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 %r14
retq
callq 0x26d77
callq 0x26d3e
// File: /workspace/github_c_makefile_star2_O1/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 0x59e95
movq %rax, %r14
leaq 0x455d9(%rip), %rdx     # 0xf5c73
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5b252
testq %r14, %r14
je 0xb06ef
movq (%rax), %rdi
testq %rdi, %rdi
je 0xb06ef
callq 0xc9969
movq %rax, (%r14)
testq %rax, %rax
je 0xb06f4
leaq 0x4d05e(%rip), %rdx     # 0xfd726
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 %r14
retq
callq 0x26de9
callq 0x26db0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xb0745
movq %rsi, %r14
testq %rsi, %rsi
je 0xb0745
movq %rdi, %rbx
movl $0x8, %esi
callq 0x59e95
movq %r14, (%rax)
leaq 0x4cf07(%rip), %rdx     # 0xfd62b
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 0x26e22
// File: /workspace/github_c_makefile_star2_O1/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 0xb0816
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x4cec3(%rip), %r14     # 0xfd62b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x3db97(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x3d4d7(%rip), %rsi     # 0xedc72
movq %rbx, %rdi
callq 0x58568
leaq 0x76(%rip), %rsi        # 0xb0820
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0x9fea8(%rip), %rdx     # 0x150670
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa856d
leaq 0x508a3(%rip), %rsi     # 0x101087
leaq 0x9ff25(%rip), %rdx     # 0x150710
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0xb081b
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x26e94
callq 0x26e5b
// File: /workspace/github_c_makefile_star2_O1/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 0xb08e4
movq %rdi, %rbx
leaq 0x4cdd2(%rip), %rdx     # 0xfd62b
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
leaq 0x44c1a(%rip), %rdx     # 0xf5487
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x4a358
movq %rax, %r15
testq %rax, %rax
jne 0xb089e
leaq 0x4d6c7(%rip), %rdx     # 0xfdf58
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
callq 0x35584
movq %rax, %r12
movq (%r14), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3e0b9
testl %eax, %eax
je 0xb08ce
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa8706
movq %r12, %rdi
callq 0x35705
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x26ecd
// File: /workspace/github_c_makefile_star2_O1/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 0xb0a01
movq %rdi, %rbx
leaq 0x4cd24(%rip), %rdx     # 0xfd62b
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
leaq 0x44b6c(%rip), %rdx     # 0xf5487
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b252
movq %rax, %r12
movq (%rax), %rdi
callq 0x3fcd9
movq %rax, %r15
testq %rax, %rax
jne 0xb094f
leaq 0x44c51(%rip), %rdx     # 0xf5593
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r12), %rdi
callq 0x41f3f
movq %rax, %r13
testq %rax, %rax
jne 0xb0974
leaq 0x4d626(%rip), %rdx     # 0xfdf8d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
callq 0x35584
movq %rax, %r12
movq (%r14), %rbp
movq %r13, %rdi
callq 0x3c40b
leaq 0x7(%rsp), %rsi
movq %rbp, %rdi
movq %rax, %rdx
movq %r12, %rcx
callq 0x3e616
testl %eax, %eax
jne 0xb09db
movq %r12, %rdi
callq 0x35705
cmpb $0x0, 0x7(%rsp)
jne 0xb09c1
leaq 0x4d5fd(%rip), %rdx     # 0xfdfb1
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
callq 0x35584
movq %rax, %r12
movq (%r14), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x3e116
testl %eax, %eax
je 0xb09f5
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa8706
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x35705
xorl %eax, %eax
jmp 0xb09e6
callq 0x26f04
// File: /workspace/github_c_makefile_star2_O1/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 0xb0a82
movq %rdi, %rbx
leaq 0x4cc0e(%rip), %rdx     # 0xfd62b
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r12
callq 0x35584
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3e1d0
testl %eax, %eax
je 0xb0a6c
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa8706
movq %r14, %rdi
callq 0x35705
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x26f3b
// File: /workspace/github_c_makefile_star2_O1/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 0x4cb92(%rip), %rdx     # 0xfd62b
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r12
callq 0x35584
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3e344
testq %rax, %rax
je 0xb0b02
movq %rax, %r15
movq %r14, %rdi
callq 0x35705
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb0e66
movq %r15, %rdi
callq 0x6f134
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 0xa8706
// File: /workspace/github_c_makefile_star2_O1/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 0x4cafe(%rip), %rdx     # 0xfd62b
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
callq 0x35584
movq %rax, %r12
movq (%r14), %rdi
leaq 0x7(%rsp), %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x3e616
testl %eax, %eax
je 0xb0b73
movq %rbx, %rdi
movq %r12, %rsi
jmp 0xb0be0
movq %r12, %rdi
callq 0x35705
cmpb $0x0, 0x7(%rsp)
jne 0xb0b96
leaq 0x4d484(%rip), %rdx     # 0xfe00d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
leaq 0x449e4(%rip), %rdx     # 0xf5581
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b252
movq %rax, %rbp
movl $0x8, %edi
callq 0x6e93c
movq %rax, %r12
callq 0x35584
movq %rax, %r13
movq (%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movq %rax, %r8
callq 0x3e39c
testl %eax, %eax
je 0xb0bf4
movq %rbx, %rdi
movq %r13, %rsi
callq 0xa8706
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x35705
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb0e66
movq %r12, %rdi
callq 0x6f134
movl $0x1, %eax
jmp 0xb0be5
// File: /workspace/github_c_makefile_star2_O1/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 0x4ca06(%rip), %rdx     # 0xfd62b
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
callq 0x35584
movq %rax, %r15
movq (%r14), %rdi
movq %rax, %rsi
callq 0x3e455
movq %rax, %r14
movq %r15, %rdi
callq 0x3566a
testb %al, %al
je 0xb0c64
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa8706
movq %r15, %rdi
callq 0x35705
movq %rbx, %rdi
testq %r14, %r14
je 0xb0c92
movq %r14, %rsi
callq 0x58568
leaq 0x4d27b(%rip), %rsi     # 0xfdefe
movq %r14, %rdi
movl $0xb5, %edx
callq 0x362a0
jmp 0xb0c97
callq 0x5834e
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4c97a(%rip), %rdx     # 0xfd62b
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
callq 0x35584
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0x3e4fa
testq %rax, %rax
je 0xb0cff
movq %rax, %r15
movq %r14, %rdi
callq 0x35705
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa85d3
movq %r15, %rdi
callq 0x3d573
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xa8706
// File: /workspace/github_c_makefile_star2_O1/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 0x4c907(%rip), %rdx     # 0xfd62b
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
callq 0x35584
movq %rax, %r12
movq (%r14), %rdi
leaq 0x7(%rsp), %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x3e616
testl %eax, %eax
jne 0xb0da4
movq %r12, %rdi
callq 0x35705
cmpb $0x0, 0x7(%rsp)
jne 0xb0d85
leaq 0x4d295(%rip), %rdx     # 0xfe00d
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
callq 0x35584
movq %rax, %r12
movq (%r14), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x3e548
testl %eax, %eax
je 0xb0dbb
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa8706
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x35705
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x89759
jmp 0xb0daf
// File: /workspace/github_c_makefile_star2_O1/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 0x4c83d(%rip), %rdx     # 0xfd62b
movl $0x1, %ebx
movl $0x1, %esi
callq 0x5b252
movq %rax, %r12
movq %r14, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r13
callq 0x35584
movq %rax, %r15
movq (%r12), %rdi
leaq 0xf(%rsp), %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x3e616
testl %eax, %eax
je 0xb0e41
movq %r14, %rdi
movq %r15, %rsi
callq 0xa8706
movl %eax, %ebx
jmp 0xb0e56
movq %r15, %rdi
callq 0x35705
movzbl 0xf(%rsp), %esi
movq %r14, %rdi
callq 0x58a14
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb0efd
movq %rsi, %r14
movq %rsi, %rdi
callq 0x6ecda
testq %rax, %rax
je 0xb0efd
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58da0
movq %r14, %rdi
callq 0x6ecda
testq %rax, %rax
je 0xb0ef1
xorl %r12d, %r12d
leaq 0x1(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x58377
movq %r14, %rdi
movq %r12, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x41ca0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x87acd
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x59193
movq %r14, %rdi
callq 0x6ecda
movq %r15, %r12
cmpq %rax, %r15
jb 0xb0ea6
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 0x5834e
// File: /workspace/github_c_makefile_star2_O1/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 0x59e95
testq %rax, %rax
je 0xb0f5f
movq %rax, %r14
callq 0x3f595
movq %rax, (%r14)
leaq 0x4c6f3(%rip), %rdx     # 0xfd62b
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 %r14
retq
callq 0x26f72
// File: /workspace/github_c_makefile_star2_O1/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 0xb1030
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x4d12f(%rip), %rsi     # 0xfe0b0
movq %rbx, %rdi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x3d381(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x3ccc1(%rip), %rsi     # 0xedc72
movq %rbx, %rdi
callq 0x58568
leaq 0x7a(%rip), %rsi        # 0xb103a
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0x9f752(%rip), %rdx     # 0x150730
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
leaq 0x5008b(%rip), %rsi     # 0x101087
leaq 0x9f74d(%rip), %rdx     # 0x150750
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0xb1035
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x26fe0
callq 0x26fa9
// File: /workspace/github_c_makefile_star2_O1/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 0x4d04d(%rip), %rdx     # 0xfe0b0
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0x41a02
testq %rax, %rax
je 0xb108f
movq %rax, %rdi
callq 0x41ca0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x87acd
jmp 0xb1097
movq %rbx, %rdi
callq 0x5834e
movl $0x1, %eax
popq %rbx
retq