LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x90149
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0x3b001
movq %rax, %r14
testq %rax, %rax
jg 0x90103
leaq 0x4e9de(%rip), %rdx     # 0xdead6
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x90173
movq %rax, %r15
movq %r14, %rdi
callq 0x4d6a4
movq %rax, (%r15)
leaq 0x5653b(%rip), %rdx     # 0xe6663
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x9de68(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39f0c(%rip), %rsi     # 0xca066
leaq 0x46895(%rip), %rdx     # 0xd69f6
leaq 0x56555(%rip), %rcx     # 0xe66bd
leaq 0x564dd(%rip), %r8      # 0xe664c
pushq $0x21
jmp 0x9019b
movq 0x9de3e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39ee2(%rip), %rsi     # 0xca066
leaq 0x564e4(%rip), %rdx     # 0xe666f
leaq 0x5652b(%rip), %rcx     # 0xe66bd
leaq 0x564b3(%rip), %r8      # 0xe664c
pushq $0x25
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x9026f
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x5652c(%rip), %rsi     # 0xe66f6
movq %rbx, %rdi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x4709a(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f41
leaq 0x469d8(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xca(%rip), %rsi        # 0x902d3
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0x9cf0b(%rip), %rdx     # 0x12d130
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
leaq 0x5a036(%rip), %rsi     # 0xea277
leaq 0x9cf08(%rip), %rdx     # 0x12d150
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x9029b
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x9dd42(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39de6(%rip), %rsi     # 0xca066
leaq 0x4676f(%rip), %rdx     # 0xd69f6
leaq 0x5643e(%rip), %rcx     # 0xe66cc
leaq 0x5644a(%rip), %r8      # 0xe66df
pushq $0x7d
popq %r9
jmp 0x902c7
movq 0x9dd16(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39dba(%rip), %rsi     # 0xca066
leaq 0x4db28(%rip), %rdx     # 0xddddb
leaq 0x56412(%rip), %rcx     # 0xe66cc
leaq 0x5641e(%rip), %r8      # 0xe66df
movl $0x8d, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x563f5(%rip), %rdx     # 0xe66f6
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
callq 0x2a4eb
movq (%r14), %rsi
movq %rax, %rdi
callq 0x29ffa
movq %rax, %r14
testq %rax, %rax
jne 0x90336
leaq 0x563de(%rip), %rdx     # 0xe6709
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r12
callq 0xbff0
movq %rax, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2a3d4
testl %eax, %eax
je 0x90376
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x88ba4
movq %r15, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0x3b001
movq %rax, %rbp
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r12
movq %rbx, %rdi
callq 0x9590b
movq %rax, %r13
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x904bd
movq %rax, %r14
movq %r12, 0x8(%rsp)
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x37b59
testl %eax, %eax
je 0x9043d
leaq 0x563aa(%rip), %rdx     # 0xe67b3
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq %r14, 0x10(%rsp)
movl %r15d, %r14d
movq %rax, %r15
callq 0xbff0
movq %rax, %r12
movl %ebp, %edx
movl 0x8(%rsp), %ecx
movq (%r15), %r8
movq %r13, %rdi
movl %r14d, %esi
movq 0x10(%rsp), %r14
jmp 0x90454
callq 0xbff0
movq %rax, %r12
movl %ebp, %edx
movl 0x8(%rsp), %ecx
movq %r13, %rdi
movl %r15d, %esi
xorl %r8d, %r8d
movq %rax, %r9
callq 0x2a575
movq %rax, (%r14)
movq %r12, %rdi
callq 0xc103
testb %al, %al
je 0x90484
movq %rbx, %rdi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x88ba4
movq %r12, %rdi
callq 0xc291
leaq 0x56263(%rip), %rdx     # 0xe66f6
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9daf4(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39b98(%rip), %rsi     # 0xca066
leaq 0x4f92a(%rip), %rdx     # 0xdfdff
leaq 0x562b5(%rip), %rcx     # 0xe6791
leaq 0x561fc(%rip), %r8      # 0xe66df
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x9053d
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x59d6a(%rip), %rsi     # 0xea277
leaq 0x9cc8c(%rip), %rdx     # 0x12d1a0
movq %rbx, %rdi
callq 0x3b11b
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x90567
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x9da74(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39b18(%rip), %rsi     # 0xca066
leaq 0x464a1(%rip), %rdx     # 0xd69f6
leaq 0x5626d(%rip), %rcx     # 0xe67c9
leaq 0x5627d(%rip), %r8      # 0xe67e0
pushq $0x37
jmp 0x9058f
movq 0x9da4a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39aee(%rip), %rsi     # 0xca066
leaq 0x4d85c(%rip), %rdx     # 0xddddb
leaq 0x56243(%rip), %rcx     # 0xe67c9
leaq 0x56253(%rip), %r8      # 0xe67e0
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x4ea45(%rip), %rdx     # 0xdeff8
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
leaq 0x4e47f(%rip), %rdx     # 0xdea44
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq %rax, %r12
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x90644
movq %rax, %r14
movq (%r15), %r15
movq (%r12), %rdi
callq 0x8908f
andl $0x0, (%rsp)
leaq 0x56220(%rip), %rcx     # 0xe681d
pushq $0x1
popq %rbp
movq %r15, %rdi
movq %rax, %rsi
movl %ebp, %edx
movl %ebp, %r8d
movl %ebp, %r9d
callq 0xc1694
movq %rax, (%r14)
leaq 0x4e9db(%rip), %rdx     # 0xdeff8
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x9d96d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39a11(%rip), %rsi     # 0xca066
leaq 0x56179(%rip), %rdx     # 0xe67d5
leaq 0x561a7(%rip), %rcx     # 0xe680a
leaq 0x56176(%rip), %r8      # 0xe67e0
pushq $0x20
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x906c5
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x59be2(%rip), %rsi     # 0xea277
leaq 0x9cb24(%rip), %rdx     # 0x12d1c0
movq %rbx, %rdi
callq 0x3b11b
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x906ef
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x9d8ec(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39990(%rip), %rsi     # 0xca066
leaq 0x46319(%rip), %rdx     # 0xd69f6
leaq 0x56142(%rip), %rcx     # 0xe6826
leaq 0x56152(%rip), %r8      # 0xe683d
pushq $0x35
jmp 0x90717
movq 0x9d8c2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39966(%rip), %rsi     # 0xca066
leaq 0x4d6d4(%rip), %rdx     # 0xddddb
leaq 0x56118(%rip), %rcx     # 0xe6826
leaq 0x56128(%rip), %r8      # 0xe683d
pushq $0x3b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x4e8c1(%rip), %rdx     # 0xdeff8
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
movq %rbx, %rdi
callq 0x377ed
movl $0x12c, %r15d           # imm = 0x12C
cmpl $0x2, %eax
jl 0x9077a
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
testq %rax, %rax
jns 0x9077a
leaq 0x560f8(%rip), %rdx     # 0xe6867
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x907ca
movq %rax, %r12
movq (%r14), %rdi
movq %r15, %rsi
callq 0xc24e7
movq %rax, (%r12)
leaq 0x4e855(%rip), %rdx     # 0xdeff8
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9d7e7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3988b(%rip), %rsi     # 0xca066
leaq 0x56050(%rip), %rdx     # 0xe6832
leaq 0x5608b(%rip), %rcx     # 0xe6874
leaq 0x5604d(%rip), %r8      # 0xe683d
pushq $0x24
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
testq %rdi, %rdi
je 0x908c3
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x56095(%rip), %rsi     # 0xe68b3
movq %rbx, %rdi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x46a46(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f41
leaq 0x46384(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xcc(%rip), %rsi        # 0x90929
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0x56097(%rip), %rdx     # 0xe6910
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
leaq 0x599e2(%rip), %rsi     # 0xea277
leaq 0x9c944(%rip), %rdx     # 0x12d1e0
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x908f1
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x9d6ee(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39792(%rip), %rsi     # 0xca066
leaq 0x4611b(%rip), %rdx     # 0xd69f6
leaq 0x55fa5(%rip), %rcx     # 0xe6887
leaq 0x55fb2(%rip), %r8      # 0xe689b
movl $0x9f, %r9d
jmp 0x9091d
movq 0x9d6c0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x39764(%rip), %rsi     # 0xca066
leaq 0x4d4d2(%rip), %rdx     # 0xddddb
leaq 0x55f77(%rip), %rcx     # 0xe6887
leaq 0x55f84(%rip), %r8      # 0xe689b
movl $0xb0, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, %r14
leaq 0x55f6a(%rip), %rdx     # 0xe68c7
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x3ae77
movq %rax, %r15
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r12
callq 0xbff0
movq %rax, %r13
movq (%r15), %rdi
leaq 0x7(%rsp), %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x17240
testl %eax, %eax
jne 0x90a25
movq %r13, %rdi
callq 0xc291
cmpb $0x0, 0x7(%rsp)
jne 0x909be
leaq 0x3cf38(%rip), %rdx     # 0xcd8eb
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x3ab1c
leaq 0x4debc(%rip), %rdx     # 0xde881
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x3ae77
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x9590b
movq %rax, 0x8(%rsp)
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x39c01
testq %rax, %rax
je 0x90a6c
movq %rax, %rbp
callq 0xbff0
movq %rax, %r13
movq (%r15), %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq %rax, %r8
callq 0x2a748
movq %rax, (%rbp)
movq %r13, %rdi
callq 0xc103
testb %al, %al
je 0x90a43
movq %r14, %rdi
movq %r13, %rsi
callq 0x88ba4
movl %eax, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0xc291
leaq 0x55e61(%rip), %rdx     # 0xe68b3
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x3914f
jmp 0x90a32
movq 0x9d545(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x395e9(%rip), %rsi     # 0xca066
leaq 0x55e3b(%rip), %rdx     # 0xe68bf
leaq 0x55e56(%rip), %rcx     # 0xe68e1
leaq 0x55e09(%rip), %r8      # 0xe689b
pushq $0x3a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5592a(%rip), %rdx     # 0xe695d
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3af85
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x426f7(%rip), %xmm0    # 0xd3750
sarq $0x3f, %rcx
cvttsd2si %xmm0, %r15
andq %rcx, %r15
orq %rax, %r15
movq (%r14), %rax
cmpq %r15, 0x8(%rax)
jae 0x91086
leaq 0x55b1a(%rip), %rdx     # 0xe6b92
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rax
movq (%rax), %rax
movzbl -0x1(%rax,%r15), %esi
movq %rbx, %rdi
callq 0x38270
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x558b2(%rip), %rdx     # 0xe695d
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %rbx
movq (%rax), %rax
movq (%rax), %rdi
leaq 0x55870(%rip), %r14     # 0xe6933
movq %r14, %rsi
movl $0xb1, %edx
callq 0xd249
movq (%rbx), %rdi
movq %r14, %rsi
movl $0xb2, %edx
callq 0xd249
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9119a
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x39c01
movq %r14, (%rax)
leaq 0x557cf(%rip), %rdx     # 0xe694a
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3914f
movq 0x9ce17(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x38ebb(%rip), %rsi     # 0xca066
leaq 0x45844(%rip), %rdx     # 0xd69f6
leaq 0x55828(%rip), %rcx     # 0xe69e1
leaq 0x55773(%rip), %r8      # 0xe6933
movl $0x415, %r9d            # imm = 0x415
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x556c4(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r12
movq (%r14), %rdi
callq 0xa1f4a
cmpq %rax, %r15
jb 0x912cc
leaq 0x55760(%rip), %rdx     # 0xe6a21
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
cmpl $0x4, %r12d
jl 0x912e4
leaq 0x55777(%rip), %rdx     # 0xe6a50
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xa1fd0
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x3825b
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x55628(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r12
movq (%r14), %rdi
callq 0xa1f4a
cmpq %rax, %r15
jb 0x91368
leaq 0x556c4(%rip), %rdx     # 0xe6a21
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
cmpl $0x4, %r12d
jl 0x91380
leaq 0x556db(%rip), %rdx     # 0xe6a50
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xa23a8
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x3828a
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x55589(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r12
cmpl $0x4, %r15d
jb 0x91400
leaq 0x5565b(%rip), %rdx     # 0xe6a50
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
callq 0xa1f4a
cmpq %rax, %r12
jb 0x9141f
leaq 0x5560d(%rip), %rdx     # 0xe6a21
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0xa3c4c
testq %rax, %rax
je 0x91471
movq %rax, %r14
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
movq %r14, (%rax)
leaq 0x5552d(%rip), %rdx     # 0xe6977
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9cb40(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x38be4(%rip), %rsi     # 0xca066
leaq 0x5ac5e(%rip), %rdx     # 0xec0e7
leaq 0x555e5(%rip), %rcx     # 0xe6a75
leaq 0x5549c(%rip), %r8      # 0xe6933
movl $0x190, %r9d            # imm = 0x190
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5548c(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r12
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r13
movq %rax, %r14
subq %r12, %r14
jae 0x914ff
leaq 0x555a8(%rip), %rdx     # 0xe6a9c
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r15), %rdi
callq 0xa1f4a
cmpq %rax, %r13
jb 0x9151e
leaq 0x5550e(%rip), %rdx     # 0xe6a21
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
incq %r14
leaq 0x5540b(%rip), %rsi     # 0xe6933
movq %r14, %rdi
movl $0xc1, %edx
callq 0xccb0
movq %rax, %rbp
movq (%r15), %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa3bb6
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x915b3
movq %rax, %r15
leaq 0x553d0(%rip), %rsi     # 0xe6933
pushq $0x10
popq %rdi
movl $0x99, %edx
callq 0xccb0
movq %rax, (%r15)
testq %rax, %rax
je 0x915e1
movq %rbp, (%rax)
movq (%r15), %rax
movq %r14, 0x8(%rax)
leaq 0x553d4(%rip), %rdx     # 0xe695d
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x9c9fe(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x38aa2(%rip), %rsi     # 0xca066
leaq 0x4380d(%rip), %rdx     # 0xd4dd8
leaq 0x554e7(%rip), %rcx     # 0xe6ab9
leaq 0x5535a(%rip), %r8      # 0xe6933
movl $0x98, %r9d
jmp 0x9160d
movq 0x9c9d0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x38a74(%rip), %rsi     # 0xca066
leaq 0x554d7(%rip), %rdx     # 0xe6ad0
leaq 0x554b9(%rip), %rcx     # 0xe6ab9
leaq 0x5532c(%rip), %r8      # 0xe6933
movl $0x9a, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x5531c(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r13
movq %rax, %r12
subq %r15, %r12
jae 0x9166f
leaq 0x55438(%rip), %rdx     # 0xe6a9c
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
callq 0xa1f4a
cmpq %rax, %r13
jb 0x9168e
leaq 0x5539e(%rip), %rdx     # 0xe6a21
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
incq %r12
leaq 0x5529b(%rip), %rsi     # 0xe6933
movq %r12, %rdi
movl $0xd2, %edx
callq 0xccb0
movq %rax, %rbp
movq (%r14), %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0xa3d89
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x3828a
movq %rbp, %rdi
leaq 0x55262(%rip), %rsi     # 0xe6933
movl $0xd5, %edx
callq 0xd249
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5524e(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
movq (%r14), %rdi
callq 0xa1f8d
cmpq %rax, %r15
jb 0x91734
leaq 0x553ac(%rip), %rdx     # 0xe6ad5
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq %r15, %rsi
callq 0xa6b5f
movq %rax, %xmm1
punpckldq 0x38d34(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x38d3c(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x551ca(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
movq (%r14), %rdi
callq 0xa1f8d
cmpq %rax, %r15
jb 0x917b8
leaq 0x55328(%rip), %rdx     # 0xe6ad5
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq %r15, %rsi
callq 0xa6788
movq %rax, %xmm1
punpckldq 0x38cb0(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x38cb8(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x55146(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
movq (%r14), %rdi
callq 0xa1f4a
cmpq %rax, %r15
jb 0x9183c
leaq 0x551f0(%rip), %rdx     # 0xe6a21
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq %r15, %rsi
callq 0xa6689
movq %rax, %xmm1
punpckldq 0x38c2c(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x38c34(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x55058(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
movq (%r14), %rdi
callq 0xa1f8d
cmpq %rax, %r15
jb 0x9192a
leaq 0x551b6(%rip), %rdx     # 0xe6ad5
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
movq %r15, %rdx
callq 0xa7510
movq (%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3828a
pushq $0x1
popq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x54fe0(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
callq 0xa7727
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38be5
pushq $-0x3
popq %rbp
movq %r14, %rdi
callq 0x157f4
cmpq %rax, %r15
jae 0x919d0
leaq 0x1(%r15), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x38270
movq %r14, %rdi
movq %r15, %rsi
callq 0x1555e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38431
movq %rbx, %rdi
movl %ebp, %esi
callq 0x38f9d
movq %r12, %r15
jmp 0x9198f
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x54f0e(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
movq (%r14), %rdi
callq 0xab8a0
cmpq %rax, %r15
jb 0x91a74
leaq 0x5508e(%rip), %rdx     # 0xe6af7
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq %r15, %rsi
callq 0xb34ea
movq %rax, %xmm1
punpckldq 0x389f4(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x389fc(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x54e8a(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
movq (%r14), %rdi
callq 0xab8a0
cmpq %rax, %r15
jb 0x91af8
leaq 0x5500a(%rip), %rdx     # 0xe6af7
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq %r15, %rsi
callq 0xb3630
movq %rax, %xmm1
punpckldq 0x38970(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x38978(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x54e06(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
movq (%r14), %rdi
callq 0xa1f4a
cmpq %rax, %r15
jb 0x91b7c
leaq 0x54eb0(%rip), %rdx     # 0xe6a21
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq %r15, %rsi
callq 0xb3583
movq %rax, %xmm1
punpckldq 0x388ec(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x388f4(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/encseq_lua.c
// Function: encseq_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 0x54d86(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x91bf1
callq 0xa6ec9
movq %rax, %rdi
callq 0x9ad5a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8f821
pushq $0x1
popq %rax
popq %rbx
retq
movq 0x9c3c0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x38464(%rip), %rsi     # 0xca066
leaq 0x54f0c(%rip), %rdx     # 0xe6b15
leaq 0x54f0d(%rip), %rcx     # 0xe6b1d
leaq 0x54d1c(%rip), %r8      # 0xe6933
movl $0x15c, %r9d            # imm = 0x15C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xbff0
movq %rax, %rbx
leaq 0x54d0a(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x91c9b
movq %rax, %r15
callq 0xb37d6
testb %al, %al
je 0x91c71
leaq 0x54edd(%rip), %rdx     # 0xe6b43
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x3ab1c
movq (%r15), %rdi
movq %rbx, %rsi
callq 0xaeeb6
testl %eax, %eax
je 0x91c8b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x88ba4
movq %rbx, %rdi
callq 0xc291
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x9c316(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x383ba(%rip), %rsi     # 0xca066
leaq 0x54e62(%rip), %rdx     # 0xe6b15
leaq 0x54e77(%rip), %rcx     # 0xe6b31
leaq 0x54c72(%rip), %r8      # 0xe6933
movl $0x167, %r9d            # imm = 0x167
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54c69(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x91d21
movq %rax, %r14
callq 0xb37d6
testb %al, %al
jne 0x91d0f
leaq 0x54e67(%rip), %rdx     # 0xe6b6b
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
callq 0xb3777
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9c290(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x38334(%rip), %rsi     # 0xca066
leaq 0x54ddc(%rip), %rdx     # 0xe6b15
leaq 0x54e17(%rip), %rcx     # 0xe6b57
leaq 0x54bec(%rip), %r8      # 0xe6933
movl $0x173, %r9d            # imm = 0x173
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x54be6(%rip), %rdx     # 0xe694a
pushq $0x1
popq %rsi
callq 0x3ae77
movq (%rax), %rdi
testq %rdi, %rdi
je 0x91d89
callq 0xb37d6
movzbl %al, %esi
movq %rbx, %rdi
callq 0x388fa
pushq $0x1
popq %rax
popq %rbx
retq
movq 0x9c228(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x382cc(%rip), %rsi     # 0xca066
leaq 0x54d74(%rip), %rdx     # 0xe6b15
leaq 0x54dd3(%rip), %rcx     # 0xe6b7b
leaq 0x54b84(%rip), %r8      # 0xe6933
movl $0x17d, %r9d            # imm = 0x17D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x54ba9(%rip), %rdx     # 0xe6977
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x3ae77
movq (%rax), %rdi
callq 0xa2941
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movq %rbx, %rdi
callq 0x3825b
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x54b72(%rip), %rdx     # 0xe6977
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x3ae77
movq (%rax), %rdi
callq 0xa33d6
leaq 0x7(%rsp), %rsi
movb %al, (%rsi)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x3828a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x54b32(%rip), %rdx     # 0xe6977
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
leaq 0x54af3(%rip), %rdx     # 0xe694a
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq %rax, %r15
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r12
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r13
cmpl $0x4, %r12d
jb 0x91e99
leaq 0x54bc2(%rip), %rdx     # 0xe6a50
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r15), %rdi
callq 0xa1f4a
cmpq %rax, %r13
jb 0x91eb8
leaq 0x54b74(%rip), %rdx     # 0xe6a21
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movq (%r15), %rsi
movl %r12d, %edx
movq %r13, %rcx
callq 0xa3924
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq