LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_use_representation
static int encseq_encoder_lua_use_representation(lua_State *L)
{
  GtEncseqEncoder **encoder;
  const char *repr;
  GtError *err;
  encoder = check_encseq_encoder(L, 1);
  repr = luaL_checkstring(L, 2);
  gt_assert(*encoder);
  err = gt_error_new();
  if (gt_encseq_encoder_use_representation(*encoder, repr, 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 0x54aaa(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
cmpq $0x0, (%r14)
je 0x91f43
movq %rax, %r12
callq 0xbff0
movq %rax, %r15
movq (%r14), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xac15b
testl %eax, %eax
je 0x91f2d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88ba4
movq %r15, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9c06e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x38112(%rip), %rsi     # 0xca066
leaq 0x54c5a(%rip), %rdx     # 0xe6bb5
leaq 0x54c5c(%rip), %rcx     # 0xe6bbe
leaq 0x549ca(%rip), %r8      # 0xe6933
movl $0x1b2, %r9d            # imm = 0x1B2
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_encoder_lua_representation
static int encseq_encoder_lua_representation(lua_State *L)
{
  GtEncseqEncoder **encoder;
  encoder = check_encseq_encoder(L, 1);
  gt_assert(*encoder);
  lua_pushstring(L, gt_str_get(gt_encseq_encoder_representation(*encoder)));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x54a0b(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x91fb3
callq 0xac6d7
movq %rax, %rdi
callq 0x143d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38431
pushq $0x1
popq %rax
popq %rbx
retq
movq 0x9bffe(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x380a2(%rip), %rsi     # 0xca066
leaq 0x54bea(%rip), %rdx     # 0xe6bb5
leaq 0x54c12(%rip), %rcx     # 0xe6be4
leaq 0x5495a(%rip), %r8      # 0xe6933
movl $0x1be, %r9d            # imm = 0x1BE
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54994(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
cmpq $0x0, (%r14)
je 0x92059
movq %rax, %r12
callq 0xbff0
movq %rax, %r15
movq (%r14), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xac0eb
testl %eax, %eax
je 0x92043
movq %rbx, %rdi
movq %r15, %rsi
callq 0x88ba4
movq %r15, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9bf58(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37ffc(%rip), %rsi     # 0xca066
leaq 0x54b44(%rip), %rdx     # 0xe6bb5
leaq 0x54b8e(%rip), %rcx     # 0xe6c06
leaq 0x548b4(%rip), %r8      # 0xe6933
movl $0x1ca, %r9d            # imm = 0x1CA
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x548f5(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x920c1
callq 0xac71a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38431
pushq $0x1
popq %rax
popq %rbx
retq
movq 0x9bef0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37f94(%rip), %rsi     # 0xca066
leaq 0x54adc(%rip), %rdx     # 0xe6bb5
leaq 0x54b4c(%rip), %rcx     # 0xe6c2c
leaq 0x5484c(%rip), %r8      # 0xe6933
movl $0x1d6, %r9d            # imm = 0x1D6
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54890(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9211a
callq 0xabae0
xorl %eax, %eax
popq %rcx
retq
movq 0x9be97(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37f3b(%rip), %rsi     # 0xca066
leaq 0x54a83(%rip), %rdx     # 0xe6bb5
leaq 0x54b15(%rip), %rcx     # 0xe6c4e
leaq 0x547f3(%rip), %r8      # 0xe6933
movl $0x1df, %r9d            # imm = 0x1DF
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54837(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92173
callq 0xabda3
xorl %eax, %eax
popq %rcx
retq
movq 0x9be3e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37ee2(%rip), %rsi     # 0xca066
leaq 0x54a2a(%rip), %rdx     # 0xe6bb5
leaq 0x54aea(%rip), %rcx     # 0xe6c7c
leaq 0x5479a(%rip), %r8      # 0xe6933
movl $0x1e8, %r9d            # imm = 0x1E8
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x547de(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x921cc
callq 0xaba9d
xorl %eax, %eax
popq %rcx
retq
movq 0x9bde5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37e89(%rip), %rsi     # 0xca066
leaq 0x549d1(%rip), %rdx     # 0xe6bb5
leaq 0x54ac0(%rip), %rcx     # 0xe6cab
leaq 0x54741(%rip), %r8      # 0xe6933
movl $0x1f1, %r9d            # imm = 0x1F1
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54785(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92225
callq 0xabde9
xorl %eax, %eax
popq %rcx
retq
movq 0x9bd8c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37e30(%rip), %rsi     # 0xca066
leaq 0x54978(%rip), %rdx     # 0xe6bb5
leaq 0x54a92(%rip), %rcx     # 0xe6cd6
leaq 0x546e8(%rip), %r8      # 0xe6933
movl $0x1fa, %r9d            # imm = 0x1FA
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5472c(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9227e
callq 0xac011
xorl %eax, %eax
popq %rcx
retq
movq 0x9bd33(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37dd7(%rip), %rsi     # 0xca066
leaq 0x5491f(%rip), %rdx     # 0xe6bb5
leaq 0x54a65(%rip), %rcx     # 0xe6d02
leaq 0x5468f(%rip), %r8      # 0xe6933
movl $0x203, %r9d            # imm = 0x203
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x546d3(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x922d7
callq 0xabb69
xorl %eax, %eax
popq %rcx
retq
movq 0x9bcda(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37d7e(%rip), %rsi     # 0xca066
leaq 0x548c6(%rip), %rdx     # 0xe6bb5
leaq 0x54a37(%rip), %rcx     # 0xe6d2d
leaq 0x54636(%rip), %r8      # 0xe6933
movl $0x20c, %r9d            # imm = 0x20C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5467a(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92330
callq 0xabf37
xorl %eax, %eax
popq %rcx
retq
movq 0x9bc81(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37d25(%rip), %rsi     # 0xca066
leaq 0x5486d(%rip), %rdx     # 0xe6bb5
leaq 0x54a0a(%rip), %rcx     # 0xe6d59
leaq 0x545dd(%rip), %r8      # 0xe6933
movl $0x215, %r9d            # imm = 0x215
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5461e(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92398
callq 0xac5cf
movzbl %al, %esi
movq %rbx, %rdi
callq 0x388fa
pushq $0x1
popq %rax
popq %rbx
retq
movq 0x9bc19(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37cbd(%rip), %rsi     # 0xca066
leaq 0x54805(%rip), %rdx     # 0xe6bb5
leaq 0x549c3(%rip), %rcx     # 0xe6d7a
leaq 0x54575(%rip), %r8      # 0xe6933
movl $0x21e, %r9d            # imm = 0x21E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x545b9(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x923f1
callq 0xabf80
xorl %eax, %eax
popq %rcx
retq
movq 0x9bbc0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37c64(%rip), %rsi     # 0xca066
leaq 0x547ac(%rip), %rdx     # 0xe6bb5
leaq 0x5498a(%rip), %rcx     # 0xe6d9a
leaq 0x5451c(%rip), %r8      # 0xe6933
movl $0x227, %r9d            # imm = 0x227
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5455d(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92459
callq 0xac611
movzbl %al, %esi
movq %rbx, %rdi
callq 0x388fa
pushq $0x1
popq %rax
popq %rbx
retq
movq 0x9bb58(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37bfc(%rip), %rsi     # 0xca066
leaq 0x54744(%rip), %rdx     # 0xe6bb5
leaq 0x54947(%rip), %rcx     # 0xe6dbf
leaq 0x544b4(%rip), %r8      # 0xe6933
movl $0x230, %r9d            # imm = 0x230
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1532c
movq %rax, %rbx
leaq 0x544e6(%rip), %rdx     # 0xe6991
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3ae77
movq %rax, %r12
callq 0xbff0
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x88ad4
testl %eax, %eax
je 0x924e9
movq %rbx, %rdi
callq 0x1583a
movq %r14, %rdi
movq %r15, %rsi
callq 0x88ba4
pushq $0x3
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3adee
movq (%r12), %rdi
testq %rdi, %rdi
je 0x92542
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xac7a4
testl %eax, %eax
je 0x92524
movq %rbx, %rdi
callq 0x1583a
movq %r14, %rdi
movq %r15, %rsi
callq 0x88ba4
movq %rbx, %rdi
callq 0x1583a
movq %r15, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9ba6f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37b13(%rip), %rsi     # 0xca066
leaq 0x5465b(%rip), %rdx     # 0xe6bb5
leaq 0x54882(%rip), %rcx     # 0xe6de3
leaq 0x543cb(%rip), %r8      # 0xe6933
movl $0x242, %r9d            # imm = 0x242
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5442a(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9259b
callq 0xae8cc
xorl %eax, %eax
popq %rcx
retq
movq 0x9ba16(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37aba(%rip), %rsi     # 0xca066
leaq 0x5484a(%rip), %rdx     # 0xe6dfd
leaq 0x5484b(%rip), %rcx     # 0xe6e05
leaq 0x54372(%rip), %r8      # 0xe6933
movl $0x266, %r9d            # imm = 0x266
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x543d1(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x925f4
callq 0xaea32
xorl %eax, %eax
popq %rcx
retq
movq 0x9b9bd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37a61(%rip), %rsi     # 0xca066
leaq 0x547f1(%rip), %rdx     # 0xe6dfd
leaq 0x54817(%rip), %rcx     # 0xe6e2a
leaq 0x54319(%rip), %r8      # 0xe6933
movl $0x26f, %r9d            # imm = 0x26F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54378(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9264d
callq 0xaee5c
xorl %eax, %eax
popq %rcx
retq
movq 0x9b964(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37a08(%rip), %rsi     # 0xca066
leaq 0x54798(%rip), %rdx     # 0xe6dfd
leaq 0x547e4(%rip), %rcx     # 0xe6e50
leaq 0x542c0(%rip), %r8      # 0xe6933
movl $0x278, %r9d            # imm = 0x278
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5431f(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x926a6
callq 0xae8ba
xorl %eax, %eax
popq %rcx
retq
movq 0x9b90b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x379af(%rip), %rsi     # 0xca066
leaq 0x5473f(%rip), %rdx     # 0xe6dfd
leaq 0x547b9(%rip), %rcx     # 0xe6e7e
leaq 0x54267(%rip), %r8      # 0xe6933
movl $0x281, %r9d            # imm = 0x281
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x542c6(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x926ff
callq 0xaee6e
xorl %eax, %eax
popq %rcx
retq
movq 0x9b8b2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37956(%rip), %rsi     # 0xca066
leaq 0x546e6(%rip), %rdx     # 0xe6dfd
leaq 0x5478b(%rip), %rcx     # 0xe6ea9
leaq 0x5420e(%rip), %r8      # 0xe6933
movl $0x28a, %r9d            # imm = 0x28A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5426d(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92758
callq 0xae8ab
xorl %eax, %eax
popq %rcx
retq
movq 0x9b859(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x378fd(%rip), %rsi     # 0xca066
leaq 0x5468d(%rip), %rdx     # 0xe6dfd
leaq 0x5475d(%rip), %rcx     # 0xe6ed4
leaq 0x541b5(%rip), %r8      # 0xe6933
movl $0x293, %r9d            # imm = 0x293
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54214(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x927b1
callq 0xae9e5
xorl %eax, %eax
popq %rcx
retq
movq 0x9b800(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x378a4(%rip), %rsi     # 0xca066
leaq 0x54634(%rip), %rdx     # 0xe6dfd
leaq 0x5472c(%rip), %rcx     # 0xe6efc
leaq 0x5415c(%rip), %r8      # 0xe6933
movl $0x29c, %r9d            # imm = 0x29C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x541bb(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x9280a
callq 0xae8b0
xorl %eax, %eax
popq %rcx
retq
movq 0x9b7a7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3784b(%rip), %rsi     # 0xca066
leaq 0x545db(%rip), %rdx     # 0xe6dfd
leaq 0x546fe(%rip), %rcx     # 0xe6f27
leaq 0x54103(%rip), %r8      # 0xe6933
movl $0x2a5, %r9d            # imm = 0x2A5
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54162(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92863
callq 0xae9ef
xorl %eax, %eax
popq %rcx
retq
movq 0x9b74e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x377f2(%rip), %rsi     # 0xca066
leaq 0x54582(%rip), %rdx     # 0xe6dfd
leaq 0x546cd(%rip), %rcx     # 0xe6f4f
leaq 0x540aa(%rip), %r8      # 0xe6933
movl $0x2ae, %r9d            # imm = 0x2AE
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54109(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x928bc
callq 0xae90f
xorl %eax, %eax
popq %rcx
retq
movq 0x9b6f5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37799(%rip), %rsi     # 0xca066
leaq 0x54529(%rip), %rdx     # 0xe6dfd
leaq 0x5468d(%rip), %rcx     # 0xe6f68
leaq 0x54051(%rip), %r8      # 0xe6933
movl $0x2b7, %r9d            # imm = 0x2B7
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbff0
movq %rax, %rbx
leaq 0x540a1(%rip), %rdx     # 0xe69ac
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3ae77
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3adee
movq (%r15), %rdi
testq %rdi, %rdi
je 0x92964
movq %rax, %rsi
movq %rbx, %rdx
callq 0xaac09
movq %r14, %rdi
testq %rax, %rax
je 0x9294b
movq %rax, %rsi
callq 0x9115a
jmp 0x92953
movq %rbx, %rsi
callq 0x88ba4
movq %rbx, %rdi
callq 0xc291
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x9b64d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x376f1(%rip), %rsi     # 0xca066
leaq 0x54481(%rip), %rdx     # 0xe6dfd
leaq 0x54605(%rip), %rcx     # 0xe6f88
leaq 0x53fa9(%rip), %r8      # 0xe6933
movl $0x2c4, %r9d            # imm = 0x2C4
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54022(%rip), %rdx     # 0xe69c6
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x929bd
callq 0xaf23c
xorl %eax, %eax
popq %rcx
retq
movq 0x9b5f4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37698(%rip), %rsi     # 0xca066
leaq 0x545d5(%rip), %rdx     # 0xe6faa
leaq 0x545d7(%rip), %rcx     # 0xe6fb3
leaq 0x53f50(%rip), %r8      # 0xe6933
movl $0x2eb, %r9d            # imm = 0x2EB
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x53fc9(%rip), %rdx     # 0xe69c6
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92a16
callq 0xaf283
xorl %eax, %eax
popq %rcx
retq
movq 0x9b59b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3763f(%rip), %rsi     # 0xca066
leaq 0x5457c(%rip), %rdx     # 0xe6faa
leaq 0x545ac(%rip), %rcx     # 0xe6fe1
leaq 0x53ef7(%rip), %r8      # 0xe6933
movl $0x2f4, %r9d            # imm = 0x2F4
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x53f70(%rip), %rdx     # 0xe69c6
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92a6f
callq 0xaf2ca
xorl %eax, %eax
popq %rcx
retq
movq 0x9b542(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x375e6(%rip), %rsi     # 0xca066
leaq 0x54523(%rip), %rdx     # 0xe6faa
leaq 0x54582(%rip), %rcx     # 0xe7010
leaq 0x53e9e(%rip), %r8      # 0xe6933
movl $0x2fd, %r9d            # imm = 0x2FD
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x53f17(%rip), %rdx     # 0xe69c6
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92ac8
callq 0xaf30d
xorl %eax, %eax
popq %rcx
retq
movq 0x9b4e9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3758d(%rip), %rsi     # 0xca066
leaq 0x544ca(%rip), %rdx     # 0xe6faa
leaq 0x54554(%rip), %rcx     # 0xe703b
leaq 0x53e45(%rip), %r8      # 0xe6933
movl $0x306, %r9d            # imm = 0x306
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x53eb7(%rip), %rdx     # 0xe69c6
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %rbx
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0x37b59
testl %eax, %eax
je 0x92b4b
pushq $0x3
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
jmp 0x92b52
leaq 0x44f8d(%rip), %r15     # 0xd7adf
movq (%r14), %r14
testq %r14, %r14
je 0x92b7b
movq %rbx, %rdi
callq 0xb260
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0xaf350
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x9b436(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x374da(%rip), %rsi     # 0xca066
leaq 0x54417(%rip), %rdx     # 0xe6faa
leaq 0x544cd(%rip), %rcx     # 0xe7067
leaq 0x53d92(%rip), %r8      # 0xe6933
movl $0x315, %r9d            # imm = 0x315
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x53dfb(%rip), %rdx     # 0xe69c6
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
callq 0xbff0
movq %rax, %rbx
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x37b59
cmpl $0x5, %eax
jne 0x92c9b
movq %r14, 0x10(%rsp)
movq %rbx, (%rsp)
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x38065
movq %rax, %r12
leaq 0x53d23(%rip), %rsi     # 0xe6933
movq %rax, %rdi
movl $0x327, %edx            # imm = 0x327
callq 0xccb0
movq %rax, 0x8(%rsp)
pushq $0x1
popq %rbp
pushq $-0x1
popq %r14
pushq $-0x2
popq %r13
xorl %ebx, %ebx
cmpq %r12, %rbp
ja 0x92cb0
movq %r15, %rdi
pushq $0x2
popq %rsi
movl %ebp, %edx
callq 0x38b62
movq %r15, %rdi
movl %r14d, %esi
callq 0x37bad
testl %eax, %eax
je 0x92cbf
testl %ebx, %ebx
movl %r14d, %ebx
jne 0x92c8b
movq %r15, %rdi
movl %r14d, %esi
callq 0x37f48
cmpl $0x100, %eax            # imm = 0x100
jl 0x92c80
movq (%rsp), %rdi
leaq 0x54466(%rip), %rsi     # 0xe70da
xorl %eax, %eax
callq 0xc007
movl %r14d, %ebx
jmp 0x92c8b
movq 0x8(%rsp), %rcx
movb %al, -0x1(%rcx,%rbp)
xorl %ebx, %ebx
movq %r15, %rdi
movl %r13d, %esi
callq 0x377fa
incq %rbp
jmp 0x92c2f
leaq 0x543ff(%rip), %rsi     # 0xe70a1
xorl %r12d, %r12d
movq $0x0, 0x8(%rsp)
jmp 0x92ccf
testl %ebx, %ebx
movq (%rsp), %rbx
movq 0x10(%rsp), %r14
jne 0x92cd9
jmp 0x92ce4
movq (%rsp), %rbx
movq 0x10(%rsp), %r14
leaq 0x543ea(%rip), %rsi     # 0xe70b9
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc007
movq %r15, %rdi
movq %rbx, %rsi
callq 0x88ba4
pushq $0x3
popq %rsi
movq %r15, %rdi
callq 0x37b59
testl %eax, %eax
je 0x92d05
pushq $0x3
popq %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %rcx
jmp 0x92d0c
leaq 0x44dd3(%rip), %rcx     # 0xd7adf
movq (%r14), %rdi
testq %rdi, %rdi
je 0x92d51
movq 0x8(%rsp), %r14
movq %r14, %rsi
movq %r12, %rdx
callq 0xafba7
leaq 0x53c08(%rip), %rsi     # 0xe6933
movq %r14, %rdi
movl $0x34e, %edx            # imm = 0x34E
callq 0xd249
movq %rbx, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9b260(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37304(%rip), %rsi     # 0xca066
leaq 0x54241(%rip), %rdx     # 0xe6faa
leaq 0x54312(%rip), %rcx     # 0xe7082
leaq 0x53bbc(%rip), %r8      # 0xe6933
movl $0x34c, %r9d            # imm = 0x34C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x53c2e(%rip), %rdx     # 0xe69c6
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
callq 0xbff0
movq %rax, %r14
movq (%r15), %rdi
movq %rax, %rsi
callq 0xafe13
movq %rbx, %rdi
testq %rax, %rax
je 0x92dc8
movq %rax, %rsi
callq 0x9115a
jmp 0x92dd0
movq %r14, %rsi
callq 0x88ba4
movq %r14, %rdi
callq 0xc291
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rsi
callq 0x39c01
testq %rax, %rax
je 0x92e4b
movq %rax, %r14
callq 0xaba47
movq %rax, (%r14)
testq %rax, %rax
je 0x92e79
leaq 0x53b69(%rip), %rdx     # 0xe6991
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9b166(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3720a(%rip), %rsi     # 0xca066
leaq 0x53d53(%rip), %rdx     # 0xe6bb6
leaq 0x542bc(%rip), %rcx     # 0xe7126
leaq 0x53ac2(%rip), %r8      # 0xe6933
movl $0x1a3, %r9d            # imm = 0x1A3
jmp 0x92ea5
movq 0x9b138(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x371dc(%rip), %rsi     # 0xca066
leaq 0x53d24(%rip), %rdx     # 0xe6bb5
leaq 0x5428e(%rip), %rcx     # 0xe7126
leaq 0x53a94(%rip), %r8      # 0xe6933
movl $0x1a5, %r9d            # imm = 0x1A5
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rsi
callq 0x39c01
testq %rax, %rax
je 0x92eff
movq %rax, %r14
callq 0xaabb9
movq %rax, (%r14)
testq %rax, %rax
je 0x92f2d
leaq 0x53ad0(%rip), %rdx     # 0xe69ac
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9b0b2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37156(%rip), %rsi     # 0xca066
leaq 0x53ee7(%rip), %rdx     # 0xe6dfe
leaq 0x5421f(%rip), %rcx     # 0xe713d
leaq 0x53a0e(%rip), %r8      # 0xe6933
movl $0x25a, %r9d            # imm = 0x25A
jmp 0x92f59
movq 0x9b084(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37128(%rip), %rsi     # 0xca066
leaq 0x53eb8(%rip), %rdx     # 0xe6dfd
leaq 0x541f1(%rip), %rcx     # 0xe713d
leaq 0x539e0(%rip), %r8      # 0xe6933
movl $0x25c, %r9d            # imm = 0x25C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rsi
callq 0x39c01
movq %rax, %r14
leaq 0x4bff5(%rip), %rdx     # 0xdef73
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
testq %r14, %r14
je 0x92fcd
movq (%rax), %rdi
testq %rdi, %rdi
je 0x92fcd
callq 0xaefff
movq %rax, (%r14)
testq %rax, %rax
je 0x92ffb
leaq 0x53a1c(%rip), %rdx     # 0xe69c6
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9afe4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x37088(%rip), %rsi     # 0xca066
leaq 0x5416e(%rip), %rdx     # 0xe7153
leaq 0x54179(%rip), %rcx     # 0xe7165
leaq 0x53940(%rip), %r8      # 0xe6933
movl $0x2df, %r9d            # imm = 0x2DF
jmp 0x93027
movq 0x9afb6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3705a(%rip), %rsi     # 0xca066
leaq 0x53f97(%rip), %rdx     # 0xe6faa
leaq 0x5414b(%rip), %rcx     # 0xe7165
leaq 0x53912(%rip), %r8      # 0xe6933
movl $0x2e1, %r9d            # imm = 0x2E1
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x93079
movq %rsi, %r14
testq %rsi, %rsi
je 0x93079
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x39c01
movq %r14, (%rax)
leaq 0x5386d(%rip), %rdx     # 0xe68c7
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3914f
movq 0x9af38(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x36fdc(%rip), %rsi     # 0xca066
leaq 0x540eb(%rip), %rdx     # 0xe717c
leaq 0x540ec(%rip), %rcx     # 0xe7184
leaq 0x540ff(%rip), %r8      # 0xe719e
movl $0xf7, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x93180
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x537f5(%rip), %r14     # 0xe68c7
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x4418f(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x38f41
leaq 0x43acd(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xd2(%rip), %rsi        # 0x931e6
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0x9a520(%rip), %rdx     # 0x12d650
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x88975
leaq 0x5712b(%rip), %rsi     # 0xea277
leaq 0x9a59d(%rip), %rdx     # 0x12d6f0
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r15d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x931ae
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x9ae31(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x36ed5(%rip), %rsi     # 0xca066
leaq 0x4385e(%rip), %rdx     # 0xd69f6
leaq 0x5401d(%rip), %rcx     # 0xe71bc
leaq 0x53ff8(%rip), %r8      # 0xe719e
movl $0x11c, %r9d            # imm = 0x11C
jmp 0x931da
movq 0x9ae03(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x36ea7(%rip), %rsi     # 0xca066
leaq 0x4ac15(%rip), %rdx     # 0xddddb
leaq 0x53fef(%rip), %rcx     # 0xe71bc
leaq 0x53fca(%rip), %r8      # 0xe719e
movl $0x12d, %r9d            # imm = 0x12D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x932a2
movq %rdi, %rbx
leaq 0x536aa(%rip), %rdx     # 0xe68c7
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
leaq 0x4b558(%rip), %rdx     # 0xde787
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq (%rax), %rdi
callq 0x26c21
movq %rax, %r15
testq %rax, %rax
jne 0x9325c
leaq 0x53fa7(%rip), %rdx     # 0xe71f8
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
callq 0xbff0
movq %rax, %r12
movq (%r14), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x16a3d
testl %eax, %eax
je 0x9328c
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x88ba4
movq %r12, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9ad0f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x36db3(%rip), %rsi     # 0xca066
leaq 0x4373c(%rip), %rdx     # 0xd69f6
leaq 0x53f15(%rip), %rcx     # 0xe71d6
leaq 0x53ed6(%rip), %r8      # 0xe719e
pushq $0x2e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x933e6
movq %rdi, %rbx
leaq 0x535d1(%rip), %rdx     # 0xe68c7
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
leaq 0x4b47f(%rip), %rdx     # 0xde787
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq %rax, %r12
movq (%rax), %rdi
callq 0x18df7
movq %rax, %r15
testq %rax, %rax
jne 0x93338
leaq 0x4b566(%rip), %rdx     # 0xde893
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r12), %rdi
callq 0x1c31a
movq %rax, %r13
testq %rax, %rax
jne 0x9335b
leaq 0x53edd(%rip), %rdx     # 0xe722d
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
callq 0xbff0
movq %rax, %r12
movq (%r14), %rbp
movq %r13, %rdi
callq 0x143d2
leaq 0x7(%rsp), %rsi
movq %rbp, %rdi
movq %rax, %rdx
movq %r12, %rcx
callq 0x17240
testl %eax, %eax
jne 0x933c0
movq %r12, %rdi
callq 0xc291
cmpb $0x0, 0x7(%rsp)
jne 0x933a6
leaq 0x53eb6(%rip), %rdx     # 0xe7251
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
callq 0xbff0
movq %rax, %r12
movq (%r14), %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x16acd
testl %eax, %eax
je 0x933da
movq %rbx, %rdi
movq %r12, %rsi
callq 0x88ba4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0xc291
xorl %eax, %eax
jmp 0x933cb
movq 0x9abcb(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x36c6f(%rip), %rsi     # 0xca066
leaq 0x435f8(%rip), %rdx     # 0xd69f6
leaq 0x53e05(%rip), %rcx     # 0xe720a
leaq 0x53d92(%rip), %r8      # 0xe719e
pushq $0x51
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x93494
movq %rdi, %rbx
leaq 0x53494(%rip), %rdx     # 0xe68c7
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r12
callq 0xbff0
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x16bed
testl %eax, %eax
je 0x9347e
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x88ba4
movq %r14, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9ab1d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x36bc1(%rip), %rsi     # 0xca066
leaq 0x4354a(%rip), %rdx     # 0xd69f6
leaq 0x53ddb(%rip), %rcx     # 0xe728e
leaq 0x53ce4(%rip), %r8      # 0xe719e
pushq $0x3f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300