LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xad398
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x50074(%rip), %rsi     # 0xfd35d
movq %rbx, %rdi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x40fd1(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x40911(%rip), %rsi     # 0xedc2a
movq %rbx, %rdi
callq 0x5790a
leaq 0x7a(%rip), %rsi        # 0xad3a2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0xa2d7a(%rip), %rdx     # 0x1500c0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
leaq 0x53c97(%rip), %rsi     # 0x100ffb
leaq 0xa2dc5(%rip), %rdx     # 0x150130
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0xad39d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x25ea8
callq 0x25e6f
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4fe31(%rip), %rdx     # 0xfd35d
movl $0x1, %esi
callq 0x5a67c
movq %rax, (%r14)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r12
movq %rax, (%r15)
testq %rax, %rax
jns 0xad568
leaq 0x4fe18(%rip), %rdx     # 0xfd370
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r15), %r12
movq (%r14), %rax
movq (%rax), %rdi
callq 0x71194
cmpq %rax, %r12
jae 0xad584
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4fdfa(%rip), %rdx     # 0xfd385
movq %rbx, %rdi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5a2e1
// File: /workspace/github_c_makefile_star2_O3/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 0x4fda2(%rip), %r12     # 0xfd35d
movl $0x1, %esi
movq %r12, %rdx
callq 0x5a67c
movq %rax, (%r15)
movq %rbx, %rdi
movl $0x2, %esi
movq %r12, %rdx
callq 0x5a67c
movq %rax, (%r14)
movq (%r15), %rax
movq (%rax), %rdi
callq 0x71194
movq %rax, %r15
movq (%r14), %rax
movq (%rax), %rdi
callq 0x71194
cmpq %rax, %r15
jne 0xad608
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4fd8b(%rip), %rdx     # 0xfd39a
movq %rbx, %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5a2e1
// File: /workspace/github_c_makefile_star2_O3/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 0xad6a6
movq %rdi, %rbx
movl $0x1, %esi
callq 0x5a844
movq %rax, %r14
testq %rax, %rax
jg 0xad65a
leaq 0x48129(%rip), %rdx     # 0xf5776
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0xad6ab
movq %rax, %r15
movq %r14, %rdi
callq 0x70cd4
movq %rax, (%r15)
leaq 0x4fcdc(%rip), %rdx     # 0xfd35d
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x25f18
callq 0x25ee1
// File: /workspace/github_c_makefile_star2_O3/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 0xad77c
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x4fd23(%rip), %rsi     # 0xfd3f0
movq %rbx, %rdi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x40bed(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x4052d(%rip), %rsi     # 0xedc2a
movq %rbx, %rdi
callq 0x5790a
leaq 0x7a(%rip), %rsi        # 0xad786
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0xa2a26(%rip), %rdx     # 0x150150
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
leaq 0x538b3(%rip), %rsi     # 0x100ffb
leaq 0xa2a21(%rip), %rdx     # 0x150170
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0xad781
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x25f88
callq 0x25f4f
// File: /workspace/github_c_makefile_star2_O3/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 0x4fc3a(%rip), %rdx     # 0xfd3f0
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
callq 0x4c08e
movq (%r14), %rsi
movq %rax, %rdi
callq 0x4be89
movq %rax, %r14
testq %rax, %rax
jne 0xad7ef
leaq 0x4fc21(%rip), %rdx     # 0xfd403
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r12
callq 0x34f04
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x4bffc
testl %eax, %eax
je 0xad831
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa7d4a
movq %r15, %rdi
callq 0x35085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5a844
movq %rax, %r13
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r12
movq %rbx, %rdi
callq 0xb1c05
movq %rax, %rbp
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0xad98e
movq %rax, %r14
movq %r12, 0x8(%rsp)
movq %rbx, %rdi
movl $0x3, %esi
callq 0x56f9b
testl %eax, %eax
je 0xad909
leaq 0x4fbdb(%rip), %rdx     # 0xfd4ad
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a67c
movq %r14, 0x10(%rsp)
movl %r15d, %r14d
movq %rax, %r15
callq 0x34f04
movq %rax, %r12
movl %r13d, %edx
movl 0x8(%rsp), %ecx
movq (%r15), %r8
movq %rbp, %rdi
movl %r14d, %esi
movq 0x10(%rsp), %r14
jmp 0xad921
callq 0x34f04
movq %rax, %r12
movl %r13d, %edx
movl 0x8(%rsp), %ecx
movq %rbp, %rdi
movl %r15d, %esi
xorl %r8d, %r8d
movq %rax, %r9
callq 0x4c11a
movq %rax, (%r14)
movq %r12, %rdi
callq 0x34fea
testb %al, %al
je 0xad951
movq %rbx, %rdi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa7d4a
movq %r12, %rdi
callq 0x35085
leaq 0x4fa90(%rip), %rdx     # 0xfd3f0
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x25fbf
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xad9e1
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x5364e(%rip), %rsi     # 0x100ffb
leaq 0xa280c(%rip), %rdx     # 0x1501c0
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0xad9e6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x2602d
callq 0x25ff6
// File: /workspace/github_c_makefile_star2_O3/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 0x4829b(%rip), %rdx     # 0xf5c98
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
leaq 0x47cd3(%rip), %rdx     # 0xf56e4
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a67c
movq %rax, %r12
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0xadaa1
movq %rax, %r14
movq (%r15), %r15
movq (%r12), %rdi
callq 0xa8063
movl $0x0, (%rsp)
leaq 0x4fac7(%rip), %rcx     # 0xfd517
movq %r15, %rdi
movq %rax, %rsi
movl $0x1, %edx
movl $0x1, %r8d
movl $0x1, %r9d
callq 0xd97b8
movq %rax, (%r14)
leaq 0x48222(%rip), %rdx     # 0xf5c98
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x26064
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xadaf5
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x5353a(%rip), %rsi     # 0x100ffb
leaq 0xa2718(%rip), %rdx     # 0x1501e0
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0xadafa
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x260d2
callq 0x2609b
// File: /workspace/github_c_makefile_star2_O3/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 0x48187(%rip), %rdx     # 0xf5c98
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
callq 0x56afc
movl $0x12c, %r15d           # imm = 0x12C
cmpl $0x2, %eax
jl 0xadb5a
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
testq %rax, %rax
jns 0xadb5a
leaq 0x4fa14(%rip), %rdx     # 0xfd561
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0xadbb0
movq %rax, %r12
movq (%r14), %rdi
movq %r15, %rsi
callq 0xda380
movq %rax, (%r12)
leaq 0x48113(%rip), %rdx     # 0xf5c98
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x26109
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xadc84
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x4f9d8(%rip), %rsi     # 0xfd5ad
movq %rbx, %rdi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x406e5(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x40025(%rip), %rsi     # 0xedc2a
movq %rbx, %rdi
callq 0x5790a
leaq 0x7a(%rip), %rsi        # 0xadc8e
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0x4f9de(%rip), %rdx     # 0xfd610
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
leaq 0x533ab(%rip), %rsi     # 0x100ffb
leaq 0xa25a9(%rip), %rdx     # 0x150200
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0xadc89
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x26179
callq 0x26140
// File: /workspace/github_c_makefile_star2_O3/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 0x4f8fd(%rip), %rdx     # 0xfd5c1
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
callq 0x34f04
movq %rax, %r12
movq (%r14), %rdi
leaq 0xf(%rsp), %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x3dc9a
testl %eax, %eax
je 0xadd0d
movq %rbx, %rdi
movq %r12, %rsi
jmp 0xadd9d
movq %r12, %rdi
callq 0x35085
cmpb $0x0, 0xf(%rsp)
jne 0xadd30
leaq 0x36bc8(%rip), %rdx     # 0xe48eb
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
leaq 0x477ea(%rip), %rdx     # 0xf5521
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a67c
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0xb1c05
movq %rax, %r13
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0xadde1
movq %rax, %r12
callq 0x34f04
movq %rax, %rbp
movq (%r14), %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movq %r13, %rcx
movq %rax, %r8
callq 0x4c2c0
movq %rax, (%r12)
movq %rbp, %rdi
callq 0x34fea
testb %al, %al
je 0xaddb1
movq %rbx, %rdi
movq %rbp, %rsi
callq 0xa7d4a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, %rdi
callq 0x35085
leaq 0x4f7ed(%rip), %rdx     # 0xfd5ad
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
jmp 0xadda2
callq 0x261b2
// File: /workspace/github_c_makefile_star2_O3/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 0x4f30a(%rip), %rdx     # 0xfd65d
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a7b9
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x3c3e3(%rip), %xmm0    # 0xea760
sarq $0x3f, %rcx
cvttsd2si %xmm0, %r15
andq %rcx, %r15
orq %rax, %r15
movq (%r14), %rax
cmpq %r15, 0x8(%rax)
jae 0xae3ac
leaq 0x4f4f6(%rip), %rdx     # 0xfd892
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rax
movq (%rax), %rax
movzbl -0x1(%rax,%r15), %esi
movq %rbx, %rdi
callq 0x5772d
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x4f28a(%rip), %rdx     # 0xfd65d
movl $0x1, %esi
callq 0x5a67c
movq %rax, %rbx
movq (%rax), %rax
movq (%rax), %rdi
leaq 0x4f246(%rip), %r14     # 0xfd633
movq %r14, %rsi
movl $0xb1, %edx
callq 0x35c27
movq (%rbx), %rdi
movq %r14, %rsi
movl $0xb2, %edx
callq 0x35c27
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xae4d0
movq %rsi, %r14
movq %rdi, %rbx
movl $0x8, %esi
callq 0x5924a
movq %r14, (%rax)
leaq 0x4f19b(%rip), %rdx     # 0xfd64a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x586d6
callq 0x26294
// File: /workspace/github_c_makefile_star2_O3/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 0x4f0c9(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %rax, %r12
movq (%r14), %rdi
callq 0xbff64
cmpq %rax, %r15
jb 0xae5cf
leaq 0x4f15f(%rip), %rdx     # 0xfd721
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
cmpl $0x4, %r12d
jl 0xae5e9
leaq 0x4f174(%rip), %rdx     # 0xfd750
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xbff84
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4f021(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %rax, %r12
movq (%r14), %rdi
callq 0xbff64
cmpq %rax, %r15
jb 0xae677
leaq 0x4f0b7(%rip), %rdx     # 0xfd721
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
cmpl $0x4, %r12d
jl 0xae691
leaq 0x4f0cc(%rip), %rdx     # 0xfd750
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xc0204
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x57747
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4ef74(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %rax, %r12
cmpl $0x4, %r15d
jb 0xae71d
leaq 0x4f040(%rip), %rdx     # 0xfd750
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
callq 0xbff64
cmpq %rax, %r12
jb 0xae73e
leaq 0x4eff0(%rip), %rdx     # 0xfd721
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
movq (%r14), %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0xc157a
testq %rax, %rax
je 0xae796
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
movq %r14, (%rax)
leaq 0x4ef0c(%rip), %rdx     # 0xfd677
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x262cd
// File: /workspace/github_c_makefile_star2_O3/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 0x4ee9a(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r12
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %rax, %r13
movq %rax, %r14
subq %r12, %r14
jae 0xae7f9
leaq 0x4efb0(%rip), %rdx     # 0xfd79c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r15), %rdi
callq 0xbff64
cmpq %rax, %r13
jb 0xae81a
leaq 0x4ef14(%rip), %rdx     # 0xfd721
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
incq %r14
leaq 0x4ee0f(%rip), %rsi     # 0xfd633
movq %r14, %rdi
movl $0xc1, %edx
callq 0x35862
movq %rax, %rbp
movq (%r15), %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xc14ef
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0xae8b7
movq %rax, %r15
leaq 0x4edd2(%rip), %rsi     # 0xfd633
movl $0x10, %edi
movl $0x99, %edx
callq 0x35862
movq %rax, (%r15)
testq %rax, %rax
je 0xae8bc
movq %rbp, (%rax)
movq (%r15), %rax
movq %r14, 0x8(%rax)
leaq 0x4edd4(%rip), %rdx     # 0xfd65d
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2633f
callq 0x26306
// File: /workspace/github_c_makefile_star2_O3/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 0x4ed74(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %rax, %r13
movq %rax, %r12
subq %r15, %r12
jae 0xae91f
leaq 0x4ee8a(%rip), %rdx     # 0xfd79c
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
callq 0xbff64
cmpq %rax, %r13
jb 0xae940
leaq 0x4edee(%rip), %rdx     # 0xfd721
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
incq %r12
leaq 0x4ece9(%rip), %rsi     # 0xfd633
movq %r12, %rdi
movl $0xd2, %edx
callq 0x35862
movq %rax, %rbp
movq (%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0xc1686
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x57747
movq %rbp, %rdi
leaq 0x4ecb0(%rip), %rsi     # 0xfd633
movl $0xd5, %edx
callq 0x35c27
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_O3/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 0x4ec9a(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq (%r14), %rdi
callq 0xbff74
cmpq %rax, %r15
jb 0xae9ee
leaq 0x4edf4(%rip), %rdx     # 0xfd7d5
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq %r15, %rsi
callq 0xc3d9a
movq %rax, %xmm1
punpckldq 0x32a7a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x32a82(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x4ec0e(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq (%r14), %rdi
callq 0xbff74
cmpq %rax, %r15
jb 0xaea7a
leaq 0x4ed68(%rip), %rdx     # 0xfd7d5
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq %r15, %rsi
callq 0xc3ab6
movq %rax, %xmm1
punpckldq 0x329ee(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x329f6(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x4eb82(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq (%r14), %rdi
callq 0xbff64
cmpq %rax, %r15
jb 0xaeb06
leaq 0x4ec28(%rip), %rdx     # 0xfd721
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq %r15, %rsi
callq 0xc3a1d
movq %rax, %xmm1
punpckldq 0x32962(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3296a(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x4ea94(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq (%r14), %rdi
callq 0xbff74
cmpq %rax, %r15
jb 0xaebf4
leaq 0x4ebee(%rip), %rdx     # 0xfd7d5
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
movq %r15, %rdx
callq 0xc4566
movq (%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x57747
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4ea14(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0xc469d
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x58130
movq %r14, %rdi
callq 0x3cbed
testq %rax, %rax
je 0xaeca9
xorl %r15d, %r15d
leaq 0x1(%r15), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5772d
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ca6f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58524
movq %r14, %rdi
callq 0x3cbed
movq %r12, %r15
cmpq %rax, %r12
jb 0xaec67
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4e934(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq (%r14), %rdi
callq 0xc7f91
cmpq %rax, %r15
jb 0xaed54
leaq 0x4eab0(%rip), %rdx     # 0xfd7f7
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq %r15, %rsi
callq 0xce7c3
movq %rax, %xmm1
punpckldq 0x32714(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3271c(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x4e8a8(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq (%r14), %rdi
callq 0xc7f91
cmpq %rax, %r15
jb 0xaede0
leaq 0x4ea24(%rip), %rdx     # 0xfd7f7
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq %r15, %rsi
callq 0xce851
movq %rax, %xmm1
punpckldq 0x32688(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x32690(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x4e81c(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq (%r14), %rdi
callq 0xbff64
cmpq %rax, %r15
jb 0xaee6c
leaq 0x4e8c2(%rip), %rdx     # 0xfd721
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq %r15, %rsi
callq 0xce800
movq %rax, %xmm1
punpckldq 0x325fc(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x32604(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x4e794(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaeee7
callq 0xc40a1
movq %rax, %rdi
callq 0xba023
movq %rbx, %rdi
movq %rax, %rsi
callq 0xacf84
movl $0x1, %eax
popq %rbx
retq
callq 0x26378
// File: /workspace/github_c_makefile_star2_O3/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 0x34f04
movq %rax, %rbx
leaq 0x4e747(%rip), %rdx     # 0xfd64a
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaef62
movq %rax, %r15
callq 0xce92f
testb %al, %al
je 0xaef38
leaq 0x4e918(%rip), %rdx     # 0xfd843
movq %r14, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xca874
testl %eax, %eax
je 0xaef52
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa7d4a
movq %rbx, %rdi
callq 0x35085
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x263b1
// File: /workspace/github_c_makefile_star2_O3/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 0x4e6d5(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaefb9
movq %rax, %r14
callq 0xce92f
testb %al, %al
jne 0xaefa7
leaq 0x4e8d1(%rip), %rdx     # 0xfd86b
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
movq (%r14), %rdi
callq 0xce903
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x263ea
// File: /workspace/github_c_makefile_star2_O3/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 0x4e681(%rip), %rdx     # 0xfd64a
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaeff2
callq 0xce92f
movzbl %al, %esi
movq %rbx, %rdi
callq 0x57df3
movl $0x1, %eax
popq %rbx
retq
callq 0x26423
// File: /workspace/github_c_makefile_star2_O3/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 0x4e675(%rip), %rdx     # 0xfd677
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0xc054e
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4e63e(%rip), %rdx     # 0xfd677
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0xc0f4d
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x57747
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4e5fa(%rip), %rdx     # 0xfd677
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
leaq 0x4e5b9(%rip), %rdx     # 0xfd64a
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %rax, %r12
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a844
movq %rax, %r13
cmpl $0x4, %r12d
jb 0xaf0db
leaq 0x4e682(%rip), %rdx     # 0xfd750
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
movq (%r15), %rdi
callq 0xbff64
cmpq %rax, %r13
jb 0xaf0fc
leaq 0x4e632(%rip), %rdx     # 0xfd721
movq %rbx, %rdi
movl $0x4, %esi
callq 0x5a2e1
movq (%r14), %rdi
movq (%r15), %rsi
movl %r12d, %edx
movq %r13, %rcx
callq 0xc12b5
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4e566(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
cmpq $0x0, (%r15)
je 0xaf18b
movq %rax, %r12
callq 0x34f04
movq %rax, %r14
movq (%r15), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xc84eb
testl %eax, %eax
je 0xaf175
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa7d4a
movq %r14, %rdi
callq 0x35085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2645c
// File: /workspace/github_c_makefile_star2_O3/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 0x4e4f6(%rip), %rdx     # 0xfd691
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
testq %rdi, %rdi
je 0xaf1cc
callq 0xc86a0
movq %rax, %rdi
callq 0x3bb5d
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5790a
movl $0x1, %eax
popq %rbx
retq
callq 0x26495