LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/bittab_lua.c
// Function: gt_lua_open_bittab
int gt_lua_open_bittab(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, BITTAB_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, bittab_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, bittab_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", bittab_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 0xadee4
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x4f592(%rip), %rsi     # 0xfd3c7
movq %rbx, %rdi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x404cd(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x3fe0d(%rip), %rsi     # 0xedc72
movq %rbx, %rdi
callq 0x58568
leaq 0x7a(%rip), %rsi        # 0xadeee
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0xa222e(%rip), %rdx     # 0x1500c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
leaq 0x531d7(%rip), %rsi     # 0x101087
leaq 0xa2279(%rip), %rdx     # 0x150130
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0xadee9
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x25ff8
callq 0x25fbf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/bittab_lua.c
// Function: get_bittab_and_bit
static void get_bittab_and_bit(lua_State *L, GtBittab ***bittab, GtWord *bit)
{
  *bittab = check_bittab(L, 1);
  *bit = luaL_checklong(L, 2);
  luaL_argcheck(L, *bit >= 0, 2, "bit number too small");
  luaL_argcheck(L, *bit < gt_bittab_size(**bittab), 2, "bit number too large");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4f352(%rip), %rdx     # 0xfd3c7
movl $0x1, %esi
callq 0x5b252
movq %rax, (%r14)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, (%r15)
testq %rax, %rax
jns 0xae0ab
leaq 0x4f33c(%rip), %rdx     # 0xfd3da
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r15), %r15
movq (%r14), %rax
movq (%rax), %rdi
callq 0x70bd9
cmpq %rax, %r15
jae 0xae0c4
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4f324(%rip), %rdx     # 0xfd3ef
movq %rbx, %rdi
movl $0x2, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/bittab_lua.c
// Function: get_two_bittabs
static void get_two_bittabs(lua_State *L, GtBittab ***bt1, GtBittab ***bt2)
{
 *bt1 = check_bittab(L, 1);
 *bt2 = check_bittab(L, 2);
 luaL_argcheck(L, gt_bittab_size(**bt1) == gt_bittab_size(**bt2), 1,
               "bittabs have different sizes");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4f2d2(%rip), %r12     # 0xfd3c7
movl $0x1, %esi
movq %r12, %rdx
callq 0x5b252
movq %rax, (%r15)
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x5b252
movq %rax, (%r14)
movq (%r15), %rax
movq (%rax), %rdi
callq 0x70bd9
movq %rax, %r15
movq (%r14), %rax
movq (%rax), %rdi
callq 0x70bd9
cmpq %rax, %r15
jne 0xae142
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4f2bb(%rip), %rdx     # 0xfd404
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5aeac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/bittab_lua.c
// Function: bittab_lua_new
static int bittab_lua_new(lua_State *L)
{
  GtWord num_of_bits;
  GtBittab **bittab;
  gt_assert(L);
  num_of_bits = luaL_checklong(L, 1);
  luaL_argcheck(L, num_of_bits > 0, 1, "must be > 0");
  bittab = lua_newuserdata(L, sizeof (GtBittab*));
  gt_assert(bittab);
  *bittab = gt_bittab_new(num_of_bits);
  luaL_getmetatable(L, BITTAB_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xae1e0
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5b41f
movq %rax, %r14
testq %rax, %rax
jg 0xae194
leaq 0x4764f(%rip), %rdx     # 0xf57d6
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0xae1e5
movq %rax, %r15
movq %r14, %rdi
callq 0x70724
movq %rax, (%r15)
leaq 0x4f20c(%rip), %rdx     # 0xfd3c7
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x26068
callq 0x26031
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/canvas_lua.c
// Function: gt_lua_open_canvas
int gt_lua_open_canvas(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, CANVAS_METATABLE);
  lua_pushvalue(L, -1); /* duplicate the metatable */
  lua_setfield(L, -2, "__index");
  /* set its _gc field */
  lua_pushstring(L, "__gc");
  lua_pushcfunction(L, canvas_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, canvas_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", canvas_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 0xae2b8
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x4f251(%rip), %rsi     # 0xfd45a
movq %rbx, %rdi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x400f9(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x3fa39(%rip), %rsi     # 0xedc72
movq %rbx, %rdi
callq 0x58568
leaq 0x7a(%rip), %rsi        # 0xae2c2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0xa1eea(%rip), %rdx     # 0x150150
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
leaq 0x52e03(%rip), %rsi     # 0x101087
leaq 0xa1ee5(%rip), %rdx     # 0x150170
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0xae2bd
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x260d8
callq 0x2609f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/canvas_lua.c
// Function: canvas_cairo_file_lua_to_file
static int canvas_cairo_file_lua_to_file(lua_State *L)
{
  GtCanvas **canvas;
  GtCanvasCairoFile *ccf = NULL;
  GtError *err;
  const char *fn;
  int had_err = 0;
  canvas = check_canvas(L, 1);
  ccf = canvas_cairo_file_try_cast(*canvas);
  luaL_argcheck(L, ccf, 1, "must be a CanvasCairoFile object");
  fn = luaL_checkstring(L, 2);
  gt_assert(canvas);
  err = gt_error_new();
  had_err = gt_canvas_cairo_file_to_file(ccf, fn, err);
  if (had_err)
    return 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 0x4f168(%rip), %rdx     # 0xfd45a
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
callq 0x4cd1e
movq (%r14), %rsi
movq %rax, %rdi
callq 0x4cb19
movq %rax, %r14
testq %rax, %rax
jne 0xae32b
leaq 0x4f14f(%rip), %rdx     # 0xfd46d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r12
callq 0x35584
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4cc8c
testl %eax, %eax
je 0xae36d
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa8706
movq %r15, %rdi
callq 0x35705
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/canvas_lua.c
// Function: canvas_cairo_file_lua_new_generic
static int canvas_cairo_file_lua_new_generic(lua_State *L, GtGraphicsOutType t)
{
  GtCanvas **canvas;
  GtImageInfo **ii;
  unsigned int width,
               height;
  GtError *err;
  GtStyle *style;
  width = luaL_checkint(L, 1);
  height = luaL_checkint(L, 2);
  /* create canvas */
  style = gt_lua_get_style_from_registry(L);
  canvas = lua_newuserdata(L, sizeof (GtCanvas*));
  gt_assert(canvas);
  /* if a imageinfo object is passed, it must be correct type */
  if (lua_isnil(L, 3)) {
    err = gt_error_new();
    *canvas = gt_canvas_cairo_file_new(style, t, width, height, NULL, err);
  } else {
    ii = check_imageinfo(L, 3);
    err = gt_error_new();
    *canvas = gt_canvas_cairo_file_new(style, t, width, height, *ii, err);
  }
  if (gt_error_is_set(err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  luaL_getmetatable(L, CANVAS_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5b41f
movq %rax, %r13
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r12
movq %rbx, %rdi
callq 0xb273d
movq %rax, %rbp
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0xae4ca
movq %rax, %r14
movq %r12, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x57c5c
testl %eax, %eax
je 0xae445
leaq 0x4f109(%rip), %rdx     # 0xfd517
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b252
movq %r14, 0x10(%rsp)
movl %r15d, %r14d
movq %rax, %r15
callq 0x35584
movq %rax, %r12
movl %r13d, %edx
movl 0x8(%rsp), %ecx
movq (%r15), %r8
movq %rbp, %rdi
movl %r14d, %esi
movq 0x10(%rsp), %r14
jmp 0xae45d
callq 0x35584
movq %rax, %r12
movl %r13d, %edx
movl 0x8(%rsp), %ecx
movq %rbp, %rdi
movl %r15d, %esi
xorl %r8d, %r8d
movq %rax, %r9
callq 0x4cdaa
movq %rax, (%r14)
movq %r12, %rdi
callq 0x3566a
testb %al, %al
je 0xae48d
movq %rbx, %rdi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa8706
movq %r12, %rdi
callq 0x35705
leaq 0x4efbe(%rip), %rdx     # 0xfd45a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2610f
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/cds_stream_lua.c
// Function: gt_lua_open_cds_stream
int gt_lua_open_cds_stream(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_register(L, "gt", cds_stream_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 0xae51d
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x52b9e(%rip), %rsi     # 0x101087
leaq 0xa1cd0(%rip), %rdx     # 0x1501c0
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0xae522
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2617d
callq 0x26146
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/cds_stream_lua.c
// Function: cds_stream_lua_new
static int cds_stream_lua_new(lua_State *L)
{
  GtNodeStream **cds_stream, **in_stream;
  GtRegionMapping **region_mapping;
  in_stream = check_genome_stream(L, 1);
  region_mapping = check_region_mapping(L, 2);
  cds_stream = lua_newuserdata(L, sizeof (GtNodeStream*));
  gt_assert(cds_stream);
  *cds_stream = gt_cds_stream_new(*in_stream,
                                  gt_region_mapping_ref(*region_mapping),
                                  1, /* XXX */
                                  "gtscript",
                                  true, /* XXX */
                                  true, /* XXX */
                                  false /* XXX */);
  luaL_getmetatable(L, GENOME_STREAM_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x477bf(%rip), %rdx     # 0xf5cf8
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
leaq 0x471f7(%rip), %rdx     # 0xf5744
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b252
movq %rax, %r12
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0xae5dd
movq %rax, %r14
movq (%r15), %r15
movq (%r12), %rdi
callq 0xa8a1f
movl $0x0, (%rsp)
leaq 0x4eff5(%rip), %rcx     # 0xfd581
movq %r15, %rdi
movq %rax, %rsi
movl $0x1, %edx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0xd90e0
movq %rax, (%r14)
leaq 0x47746(%rip), %rdx     # 0xf5cf8
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x261b4
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/csa_stream_lua.c
// Function: gt_lua_open_csa_stream
int gt_lua_open_csa_stream(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_register(L, "gt", csa_stream_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 0xae631
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x52a8a(%rip), %rsi     # 0x101087
leaq 0xa1bdc(%rip), %rdx     # 0x1501e0
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0xae636
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x26222
callq 0x261eb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/csa_stream_lua.c
// Function: csa_stream_lua_new
static int csa_stream_lua_new(lua_State *L)
{
  GtNodeStream **csa_stream, **in_stream;
  GtWord join_length;
  in_stream = check_genome_stream(L, 1);
  if (lua_gettop(L) >= 2) {
    join_length = luaL_checklong(L, 2);
    luaL_argcheck(L, join_length >= 0, 2, "must be >= 0");
  }
  else
    join_length = GT_DEFAULT_JOIN_LENGTH;
  csa_stream = lua_newuserdata(L, sizeof (GtNodeStream*));
  gt_assert(csa_stream);
  *csa_stream = gt_csa_stream_new(*in_stream, join_length);
  luaL_getmetatable(L, GENOME_STREAM_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x476ab(%rip), %rdx     # 0xf5cf8
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
callq 0x578c5
movl $0x12c, %r15d           # imm = 0x12C
cmpl $0x2, %eax
jl 0xae696
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
testq %rax, %rax
jns 0xae696
leaq 0x4ef42(%rip), %rdx     # 0xfd5cb
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0xae6ec
movq %rax, %r12
movq (%r14), %rdi
movq %r15, %rsi
callq 0xd9cab
movq %rax, (%r12)
leaq 0x47637(%rip), %rdx     # 0xf5cf8
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x26259
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/diagram_lua.c
// Function: gt_lua_open_diagram
int gt_lua_open_diagram(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, DIAGRAM_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, diagram_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, diagram_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", diagram_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 0xae7c0
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x4ef06(%rip), %rsi     # 0xfd617
movq %rbx, %rdi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x3fbf1(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x3f531(%rip), %rsi     # 0xedc72
movq %rbx, %rdi
callq 0x58568
leaq 0x7a(%rip), %rsi        # 0xae7ca
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0x4ef02(%rip), %rdx     # 0xfd670
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
leaq 0x528fb(%rip), %rsi     # 0x101087
leaq 0xa1a6d(%rip), %rdx     # 0x150200
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0xae7c5
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x262c9
callq 0x26290
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/diagram_lua.c
// Function: diagram_lua_new
static int diagram_lua_new(lua_State *L)
{
  GtDiagram **diagram;
  GtFeatureIndex **feature_index;
  GtRange *range;
  GtError *err;
  const char *seqid;
  GtStyle *style;
  bool has_seqid;
  /* get feature index */
  feature_index = check_feature_index(L, 1);
  /* get seqid */
  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 the given sequence id");
  /* get range */
  range = check_range(L, 3);
  /* create diagram */
  style = gt_lua_get_style_from_registry(L);
  diagram = lua_newuserdata(L, sizeof (GtDiagram*));
  gt_assert(diagram);
  err = gt_error_new();
  *diagram = gt_diagram_new(*feature_index, seqid, range, style, err);
  if (gt_error_is_set(err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  luaL_getmetatable(L, DIAGRAM_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x4ee2b(%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 0xf(%rsp), %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x3e616
testl %eax, %eax
je 0xae849
movq %rbx, %rdi
movq %r12, %rsi
jmp 0xae8d9
movq %r12, %rdi
callq 0x35705
cmpb $0x0, 0xf(%rsp)
jne 0xae86c
leaq 0x360ac(%rip), %rdx     # 0xe490b
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
leaq 0x46d0e(%rip), %rdx     # 0xf5581
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b252
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0xb273d
movq %rax, %r13
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0xae91d
movq %rax, %r12
callq 0x35584
movq %rax, %rbp
movq (%r14), %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x4cf50
movq %rax, (%r12)
movq %rbp, %rdi
callq 0x3566a
testb %al, %al
je 0xae8ed
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xa8706
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
callq 0x35705
leaq 0x4ed1b(%rip), %rdx     # 0xfd617
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
jmp 0xae8de
callq 0x26302
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_index_buffer
static int encseq_lua_index_buffer(lua_State *L)
{
  GtEncseqExtractedBuffer **buf = luaL_checkudata(L, 1,
                                                  ENCSEQ_BUFFER_METATABLE);
  GtUword num = luaL_checknumber(L, 2);
  luaL_argcheck(L, num <= (*buf)->length, 2,
                "must be inside extracted substring");
  lua_pushinteger(L, ((*buf)->buf)[num-1]);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4e826(%rip), %rdx     # 0xfd6bd
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b394
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x3b8ef(%rip), %xmm0    # 0xea7b0
sarq $0x3f, %rcx
cvttsd2si %xmm0, %r15
andq %rcx, %r15
orq %rax, %r15
movq (%r14), %rax
cmpq %r15, 0x8(%rax)
jae 0xaeeed
leaq 0x4ea12(%rip), %rdx     # 0xfd8f2
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rax
movq (%rax), %rax
movzbl -0x1(%rax,%r15), %esi
movq %rbx, %rdi
callq 0x58377
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_lua_delete_buffer
static int encseq_lua_delete_buffer(lua_State *L)
{
  GtEncseqExtractedBuffer **buf = luaL_checkudata(L, 1,
                                                  ENCSEQ_BUFFER_METATABLE);
  gt_free((*buf)->buf);
  gt_free(*buf);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x4e7a6(%rip), %rdx     # 0xfd6bd
movl $0x1, %esi
callq 0x5b252
movq %rax, %rbx
movq (%rax), %rax
movq (%rax), %rdi
leaq 0x4e762(%rip), %r14     # 0xfd693
movq %r14, %rsi
movl $0xb1, %edx
callq 0x362a0
movq (%rbx), %rdi
movq %r14, %rsi
movl $0xb2, %edx
callq 0x362a0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: gt_lua_encseq_push
void gt_lua_encseq_push(lua_State *L, GtEncseq *encseq)
{
  GtEncseq **encseqptr;
  gt_assert(L);
  encseqptr = lua_newuserdata(L, sizeof (GtEncseq*));
  *encseqptr = encseq;
  luaL_getmetatable(L, ENCSEQ_METATABLE);
  lua_setmetatable(L, -2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xaf014
movq %rsi, %r14
movq %rdi, %rbx
movl $0x8, %esi
callq 0x59e95
movq %r14, (%rax)
leaq 0x4e6b7(%rip), %rdx     # 0xfd6aa
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 0x263e4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_get_encoded_char
static int encseq_lua_get_encoded_char(lua_State *L)
{
  GtEncseq **encseq;
  GtUword pos;
  int readmode;
  unsigned char cc;
  encseq = check_encseq(L, 1);
  pos = luaL_checklong(L, 2);
  readmode = luaL_checklong(L, 3);
  luaL_argcheck(L, pos < gt_encseq_total_length(*encseq), 2,
                "cannot exceed total length of encoded sequence");
  luaL_argcheck(L, readmode <= 3, 3,
                "invalid readmode value, must be <= 3");
  cc = gt_encseq_get_encoded_char(*encseq, pos, readmode);
  lua_pushnumber(L, cc);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4e5e5(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %rax, %r12
movq (%r14), %rdi
callq 0xbef5c
cmpq %rax, %r15
jb 0xaf113
leaq 0x4e67b(%rip), %rdx     # 0xfd781
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
cmpl $0x4, %r12d
jl 0xaf12d
leaq 0x4e690(%rip), %rdx     # 0xfd7b0
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xbef7c
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_get_decoded_char
static int encseq_lua_get_decoded_char(lua_State *L)
{
  GtEncseq **encseq;
  GtUword pos;
  int readmode;
  char cc;
  encseq = check_encseq(L, 1);
  pos = luaL_checklong(L, 2);
  readmode = luaL_checklong(L, 3);
  luaL_argcheck(L, pos < gt_encseq_total_length(*encseq), 2,
                "cannot exceed total length of encoded sequence");
  luaL_argcheck(L, readmode <= 3, 3,
                "invalid readmode value, must be <= 3");
  cc = gt_encseq_get_decoded_char(*encseq, pos, readmode);
  lua_pushlstring(L, &cc, sizeof (char));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4e53d(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %rax, %r12
movq (%r14), %rdi
callq 0xbef5c
cmpq %rax, %r15
jb 0xaf1bb
leaq 0x4e5d3(%rip), %rdx     # 0xfd781
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
cmpl $0x4, %r12d
jl 0xaf1d5
leaq 0x4e5e8(%rip), %rdx     # 0xfd7b0
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xbf1fc
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x58391
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_create_reader_with_readmode
static int encseq_lua_create_reader_with_readmode(lua_State *L)
{
  GtEncseq **encseq;
  GtEncseqReader *reader;
  GtUword startpos;
  GtReadmode readmode;
  encseq = check_encseq(L, 1);
  readmode = luaL_checklong(L, 2);
  startpos = luaL_checklong(L, 3);
  luaL_argcheck(L, readmode <= 3, 2,
                "invalid readmode value, must be <= 3");
  luaL_argcheck(L, startpos < gt_encseq_total_length(*encseq), 3,
                "cannot exceed total length of encoded sequence");
  reader = gt_encseq_create_reader_with_readmode(*encseq, readmode, startpos);
  gt_assert(reader);
  gt_lua_encseq_reader_push(L, reader);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4e490(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %rax, %r12
cmpl $0x4, %r15d
jb 0xaf261
leaq 0x4e55c(%rip), %rdx     # 0xfd7b0
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
callq 0xbef5c
cmpq %rax, %r12
jb 0xaf282
leaq 0x4e50c(%rip), %rdx     # 0xfd781
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
movq (%r14), %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0xc04f1
testq %rax, %rax
je 0xaf2da
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
movq %r14, (%rax)
leaq 0x4e428(%rip), %rdx     # 0xfd6d7
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2641d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_extract_encoded
static int encseq_lua_extract_encoded(lua_State *L)
{
  GtEncseq **encseq;
  GtUword from, to;
  unsigned char *string;
  encseq = check_encseq(L, 1);
  from = luaL_checklong(L, 2);
  to = luaL_checklong(L, 3);
  luaL_argcheck(L, from <= to, 2, "must be <= range endposition");
  luaL_argcheck(L, to < gt_encseq_total_length(*encseq), 3,
                "cannot exceed total length of encoded sequence");
  string = gt_malloc((to - from + 1) * sizeof (unsigned char));
  gt_encseq_extract_encoded(*encseq, string, from, to);
  encseq_lua_push_buffer(L, string, (to - from + 1));
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4e3b6(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %rax, %r13
movq %rax, %r14
subq %r12, %r14
jae 0xaf33d
leaq 0x4e4cc(%rip), %rdx     # 0xfd7fc
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r15), %rdi
callq 0xbef5c
cmpq %rax, %r13
jb 0xaf35e
leaq 0x4e430(%rip), %rdx     # 0xfd781
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
incq %r14
leaq 0x4e32b(%rip), %rsi     # 0xfd693
movq %r14, %rdi
movl $0xc1, %edx
callq 0x35ee2
movq %rax, %rbp
movq (%r15), %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xc0464
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0xaf3fb
movq %rax, %r15
leaq 0x4e2ee(%rip), %rsi     # 0xfd693
movl $0x10, %edi
movl $0x99, %edx
callq 0x35ee2
movq %rax, (%r15)
testq %rax, %rax
je 0xaf400
movq %rbp, (%rax)
movq (%r15), %rax
movq %r14, 0x8(%rax)
leaq 0x4e2f0(%rip), %rdx     # 0xfd6bd
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2648f
callq 0x26456
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_extract_decoded
static int encseq_lua_extract_decoded(lua_State *L)
{
  GtEncseq **encseq;
  GtUword from, to;
  char *string;
  encseq = check_encseq(L, 1);
  from = luaL_checklong(L, 2);
  to = luaL_checklong(L, 3);
  luaL_argcheck(L, from <= to, 2, "must be <= range endposition");
  luaL_argcheck(L, to < gt_encseq_total_length(*encseq), 3,
                "cannot exceed total length of encoded sequence");
  string = gt_malloc((to - from + 1) * sizeof (char));
  gt_encseq_extract_decoded(*encseq, string, from, to);
  lua_pushlstring(L, string, (to - from + 1));
  gt_free(string);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4e290(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %rax, %r13
movq %rax, %r12
subq %r15, %r12
jae 0xaf463
leaq 0x4e3a6(%rip), %rdx     # 0xfd7fc
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
callq 0xbef5c
cmpq %rax, %r13
jb 0xaf484
leaq 0x4e30a(%rip), %rdx     # 0xfd781
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
incq %r12
leaq 0x4e205(%rip), %rsi     # 0xfd693
movq %r12, %rdi
movl $0xd2, %edx
callq 0x35ee2
movq %rax, %rbp
movq (%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0xc05ff
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x58391
movq %rbp, %rdi
leaq 0x4e1cc(%rip), %rsi     # 0xfd693
movl $0xd5, %edx
callq 0x362a0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_seqlength
static int encseq_lua_seqlength(lua_State *L)
{
  GtEncseq **encseq;
  GtUword pos;
  encseq = check_encseq(L, 1);
  pos = luaL_checklong(L, 2);
  luaL_argcheck(L, pos < gt_encseq_num_of_sequences(*encseq), 2,
                "cannot exceed number of sequences");
  lua_pushnumber(L, gt_encseq_seqlength(*encseq, pos));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4e1b6(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq (%r14), %rdi
callq 0xbef6c
cmpq %rax, %r15
jb 0xaf532
leaq 0x4e310(%rip), %rdx     # 0xfd835
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
movq %r15, %rsi
callq 0xc2d57
movq %rax, %xmm1
punpckldq 0x31f36(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x31f3e(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_seqstartpos
static int encseq_lua_seqstartpos(lua_State *L)
{
  GtEncseq **encseq;
  GtUword pos;
  encseq = check_encseq(L, 1);
  pos = luaL_checklong(L, 2);
  luaL_argcheck(L, pos < gt_encseq_num_of_sequences(*encseq), 2,
                "cannot exceed number of sequences");
  lua_pushnumber(L, gt_encseq_seqstartpos(*encseq, pos));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4e12a(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq (%r14), %rdi
callq 0xbef6c
cmpq %rax, %r15
jb 0xaf5be
leaq 0x4e284(%rip), %rdx     # 0xfd835
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
movq %r15, %rsi
callq 0xc2a64
movq %rax, %xmm1
punpckldq 0x31eaa(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x31eb2(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_seqnum
static int encseq_lua_seqnum(lua_State *L)
{
  GtEncseq **encseq;
  GtUword pos;
  encseq = check_encseq(L, 1);
  pos = luaL_checklong(L, 2);
  luaL_argcheck(L, pos < gt_encseq_total_length(*encseq), 2,
                "cannot exceed total length of encoded sequence");
  lua_pushnumber(L, gt_encseq_seqnum(*encseq, pos));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4e09e(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq (%r14), %rdi
callq 0xbef5c
cmpq %rax, %r15
jb 0xaf64a
leaq 0x4e144(%rip), %rdx     # 0xfd781
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
movq %r15, %rsi
callq 0xc29cc
movq %rax, %xmm1
punpckldq 0x31e1e(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x31e26(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_description
static int encseq_lua_description(lua_State *L)
{
  GtEncseq **encseq;
  GtUword seqno, desclen;
  const char *string;
  encseq = check_encseq(L, 1);
  seqno = luaL_checklong(L, 2);
  luaL_argcheck(L, seqno < gt_encseq_num_of_sequences(*encseq), 2,
                "cannot exceed number of sequences");
  string = gt_encseq_description(*encseq, &desclen, seqno);
  lua_pushlstring(L, string, desclen);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4dfb0(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq (%r14), %rdi
callq 0xbef6c
cmpq %rax, %r15
jb 0xaf738
leaq 0x4e10a(%rip), %rdx     # 0xfd835
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
movq %r15, %rdx
callq 0xc3523
movq (%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58391
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_filenames
static int encseq_lua_filenames(lua_State *L)
{
  GtEncseq **encseq;
  const GtStrArray *filenames;
  GtUword i;
  encseq = check_encseq(L, 1);
  filenames = gt_encseq_filenames(*encseq);
  lua_newtable(L);
  for (i = 0; i < gt_str_array_size(filenames); i++) {
    lua_pushinteger(L, i+1); /* in Lua we index from 1 on */
    lua_pushstring(L, gt_str_array_get(filenames, i));
    lua_rawset(L, -3);
  }
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4df30(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0xc365a
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58da0
movq %r14, %rdi
callq 0x3d560
testq %rax, %rax
je 0xaf7ed
xorl %r15d, %r15d
leaq 0x1(%r15), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x58377
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d3e2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x59193
movq %r14, %rdi
callq 0x3d560
movq %r12, %r15
cmpq %rax, %r12
jb 0xaf7ab
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_effective_filelength
static int encseq_lua_effective_filelength(lua_State *L)
{
  GtEncseq **encseq;
  GtUword fileno;
  encseq = check_encseq(L, 1);
  fileno = luaL_checklong(L, 2);
  luaL_argcheck(L, fileno < gt_encseq_num_of_files(*encseq), 2,
                "cannot exceed number of files");
  lua_pushnumber(L, gt_encseq_effective_filelength(*encseq, fileno));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4de50(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq (%r14), %rdi
callq 0xc6fb7
cmpq %rax, %r15
jb 0xaf898
leaq 0x4dfcc(%rip), %rdx     # 0xfd857
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
movq %r15, %rsi
callq 0xcd891
movq %rax, %xmm1
punpckldq 0x31bd0(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x31bd8(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_filestartpos
static int encseq_lua_filestartpos(lua_State *L)
{
  GtEncseq **encseq;
  GtUword fileno;
  encseq = check_encseq(L, 1);
  fileno = luaL_checklong(L, 2);
  luaL_argcheck(L, fileno < gt_encseq_num_of_files(*encseq), 2,
                "cannot exceed number of files");
  lua_pushnumber(L, gt_encseq_filestartpos(*encseq, fileno));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4ddc4(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq (%r14), %rdi
callq 0xc6fb7
cmpq %rax, %r15
jb 0xaf924
leaq 0x4df40(%rip), %rdx     # 0xfd857
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
movq %r15, %rsi
callq 0xcd926
movq %rax, %xmm1
punpckldq 0x31b44(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x31b4c(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_filenum
static int encseq_lua_filenum(lua_State *L)
{
  GtEncseq **encseq;
  GtUword pos;
  encseq = check_encseq(L, 1);
  pos = luaL_checklong(L, 2);
  luaL_argcheck(L, pos < gt_encseq_total_length(*encseq), 2,
                "cannot exceed total length of encoded sequence");
  lua_pushnumber(L, gt_encseq_filenum(*encseq, pos));
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4dd38(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq (%r14), %rdi
callq 0xbef5c
cmpq %rax, %r15
jb 0xaf9b0
leaq 0x4ddde(%rip), %rdx     # 0xfd781
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
movq %r15, %rsi
callq 0xcd8d3
movq %rax, %xmm1
punpckldq 0x31ab8(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x31ac0(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_alphabet
static int encseq_lua_alphabet(lua_State *L)
{
  GtEncseq **encseq;
  GtAlphabet *alpha;
  encseq = check_encseq(L, 1);
  gt_assert(*encseq);
  alpha = gt_alphabet_ref(gt_encseq_alphabet(*encseq));
  gt_lua_alphabet_push(L, alpha);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4dcb0(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafa2b
callq 0xc305e
movq %rax, %rdi
callq 0xb8fab
movq %rbx, %rdi
movq %rax, %rsi
callq 0xadad0
movl $0x1, %eax
popq %rbx
retq
callq 0x264c8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_mirror
static int encseq_lua_mirror(lua_State *L)
{
  GtEncseq **encseq;
  GtError *err = gt_error_new();
  encseq = check_encseq(L, 1);
  gt_assert(*encseq);
  luaL_argcheck(L, !gt_encseq_is_mirrored(*encseq), 1, "is already mirrored");
  if (gt_encseq_mirror(*encseq, err) != 0)
    gt_lua_error(L, err);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x35584
movq %rax, %rbx
leaq 0x4dc63(%rip), %rdx     # 0xfd6aa
movq %r14, %rdi
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafaa6
movq %rax, %r15
callq 0xcda04
testb %al, %al
je 0xafa7c
leaq 0x4de34(%rip), %rdx     # 0xfd8a3
movq %r14, %rdi
movl $0x1, %esi
callq 0x5aeac
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xc9871
testl %eax, %eax
je 0xafa96
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa8706
movq %rbx, %rdi
callq 0x35705
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x26501
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_unmirror
static int encseq_lua_unmirror(lua_State *L)
{
  GtEncseq **encseq;
  encseq = check_encseq(L, 1);
  gt_assert(*encseq);
  luaL_argcheck(L, gt_encseq_is_mirrored(*encseq), 1, "is not mirrored");
  gt_encseq_unmirror(*encseq);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4dbf1(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafafd
movq %rax, %r14
callq 0xcda04
testb %al, %al
jne 0xafaeb
leaq 0x4dded(%rip), %rdx     # 0xfd8cb
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
movq (%r14), %rdi
callq 0xcd9d8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2653a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_lua_is_mirrored
static int encseq_lua_is_mirrored(lua_State *L)
{
  GtEncseq **encseq;
  encseq = check_encseq(L, 1);
  gt_assert(*encseq);
  lua_pushboolean(L, gt_encseq_is_mirrored(*encseq));
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4db9d(%rip), %rdx     # 0xfd6aa
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafb36
callq 0xcda04
movzbl %al, %esi
movq %rbx, %rdi
callq 0x58a14
movl $0x1, %eax
popq %rbx
retq
callq 0x26573
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_reader_lua_next_encoded_char
static int encseq_reader_lua_next_encoded_char(lua_State *L)
{
  GtEncseqReader **reader;
  unsigned char cc;
  reader = check_encseq_reader(L, 1);
  cc = gt_encseq_reader_next_encoded_char(*reader);
  lua_pushnumber(L, cc);
  return 1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x4db91(%rip), %rdx     # 0xfd6d7
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0xbf542
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x58362
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_reader_lua_next_decoded_char
static int encseq_reader_lua_next_decoded_char(lua_State *L)
{
  GtEncseqReader **reader;
  char cc;
  reader = check_encseq_reader(L, 1);
  cc = gt_encseq_reader_next_decoded_char(*reader);
  lua_pushlstring(L, &cc, sizeof (char));
  return 1;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4db5a(%rip), %rdx     # 0xfd6d7
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0xbfeaf
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x58391
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_reader_lua_reinit_with_readmode
static int encseq_reader_lua_reinit_with_readmode(lua_State *L)
{
  GtEncseq **encseq;
  GtEncseqReader **reader;
  GtUword startpos;
  GtReadmode readmode;
  reader = check_encseq_reader(L, 1);
  encseq = check_encseq(L, 2);
  readmode = luaL_checklong(L, 3);
  startpos = luaL_checklong(L, 4);
  luaL_argcheck(L, readmode <= 3, 3,
                "invalid readmode value, must be <= 3");
  luaL_argcheck(L, startpos < gt_encseq_total_length(*encseq), 4,
                "cannot exceed total length of encoded sequence");
  gt_encseq_reader_reinit_with_readmode(*reader, *encseq, readmode, startpos);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x4db16(%rip), %rdx     # 0xfd6d7
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
leaq 0x4dad5(%rip), %rdx     # 0xfd6aa
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5b41f
movq %rax, %r13
cmpl $0x4, %r12d
jb 0xafc1f
leaq 0x4db9e(%rip), %rdx     # 0xfd7b0
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
movq (%r15), %rdi
callq 0xbef5c
cmpq %rax, %r13
jb 0xafc40
leaq 0x4db4e(%rip), %rdx     # 0xfd781
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5aeac
movq (%r14), %rdi
movq (%r15), %rsi
movl %r12d, %edx
movq %r13, %rcx
callq 0xc0212
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4da82(%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 0xafccf
movq %rax, %r12
callq 0x35584
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xc7555
testl %eax, %eax
je 0xafcb9
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 0x265ac
// File: /workspace/github_c_makefile_star2_O1/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 0x4da12(%rip), %rdx     # 0xfd6f1
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
testq %rdi, %rdi
je 0xafd10
callq 0xc770a
movq %rax, %rdi
callq 0x3c40b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x58568
movl $0x1, %eax
popq %rbx
retq
callq 0x265e5