LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: gt_lua_open_region_mapping
int gt_lua_open_region_mapping(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, REGION_MAPPING_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, region_mapping_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, region_mapping_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", region_mapping_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 0x6a044
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x74aa5(%rip), %rsi     # 0xdea44
movq %rbx, %rdi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x6d2c5(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f41
leaq 0x6cc03(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xcc(%rip), %rsi        # 0x6a0aa
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0xc2c56(%rip), %rdx     # 0x12cc50
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
leaq 0x80261(%rip), %rsi     # 0xea277
leaq 0xc2c83(%rip), %rdx     # 0x12cca0
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x6a072
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0xc3f6d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x60011(%rip), %rsi     # 0xca066
leaq 0x6c99a(%rip), %rdx     # 0xd69f6
leaq 0x74c8e(%rip), %rcx     # 0xdecf1
leaq 0x74c68(%rip), %r8      # 0xdecd2
movl $0xeb, %r9d
jmp 0x6a09e
movq 0xc3f3f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5ffe3(%rip), %rsi     # 0xca066
leaq 0x73d51(%rip), %rdx     # 0xddddb
leaq 0x74c60(%rip), %rcx     # 0xdecf1
leaq 0x74c3a(%rip), %r8      # 0xdecd2
movl $0xfc, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_get_sequence_length
static int region_mapping_lua_get_sequence_length(lua_State *L)
{
  GtRegionMapping **region_mapping;
  GtError *err;
  GtStr *seqidstr;
  GtUword length;
  const char *seqid;
  int had_err = 0;
  gt_assert(L);
  region_mapping = check_region_mapping(L, 1);
  seqid = luaL_checkstring(L, 2);
  seqidstr = gt_str_new_cstr(seqid);
  err = gt_error_new();
  had_err = gt_region_mapping_get_sequence_length(*region_mapping, &length,
                                                  seqidstr, err);
  gt_str_delete(seqidstr);
  if (had_err)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  lua_pushnumber(L, length);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6a181
movq %rdi, %r14
leaq 0x74960(%rip), %rdx     # 0xdea44
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x3ae77
movq %rax, %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %rdi
callq 0x13da9
movq %rax, %r13
callq 0xbff0
movq %rax, %r15
movq (%r12), %rdi
movq %rsp, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x8996c
movl %eax, %ebp
movq %r13, %rdi
callq 0x152db
testl %ebp, %ebp
je 0x6a140
movq %r14, %rdi
movq %r15, %rsi
callq 0x88ba4
movl %eax, %ebx
jmp 0x6a170
movq %r15, %rdi
callq 0xc291
movsd (%rsp), %xmm1
unpcklps 0x6032c(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x60334(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x3825b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc3e30(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5fed4(%rip), %rsi     # 0xca066
leaq 0x6c85d(%rip), %rdx     # 0xd69f6
leaq 0x74b6c(%rip), %rcx     # 0xded0c
leaq 0x74b2b(%rip), %r8      # 0xdecd2
pushq $0x62
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_get_sequence
static int region_mapping_lua_get_sequence(lua_State *L)
{
  GtRegionMapping **region_mapping;
  GtError *err;
  GtStr *seqidstr;
  char *result;
  GtUword start, end;
  const char *seqid;
  int had_err = 0;
  gt_assert(L);
  region_mapping = check_region_mapping(L, 1);
  seqid = luaL_checkstring(L, 2);
  start = luaL_checknumber(L, 3);
  end = luaL_checknumber(L, 4);
  luaL_argcheck(L, start > 0, 3, "must be > 0");
  luaL_argcheck(L, end > 0, 4, "must be > 0");
  luaL_argcheck(L, start <= end, 3, "must be <= endpos");
  seqidstr = gt_str_new_cstr(seqid);
  err = gt_error_new();
  had_err = gt_region_mapping_get_sequence(*region_mapping, &result, seqidstr,
                                           start, end, err);
  gt_str_delete(seqidstr);
  if (had_err)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  lua_pushstring(L, result);
  gt_free(result);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x6a31a
movq %rdi, %r14
leaq 0x7486c(%rip), %rdx     # 0xdea44
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x3ae77
movq %rax, 0x10(%rsp)
pushq $0x2
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r13
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x3af85
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x6953a(%rip), %xmm0    # 0xd3750
cvttsd2si %xmm0, %r12
andq %rcx, %r12
orq %rax, %r12
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x3af85
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x69514(%rip), %xmm0    # 0xd3750
cvttsd2si %xmm0, %rbp
sarq $0x3f, %rcx
andq %rcx, %rbp
orq %rax, %rbp
testq %r12, %r12
jne 0x6a262
leaq 0x7487f(%rip), %rdx     # 0xdead6
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x3ab1c
testq %rbp, %rbp
jne 0x6a279
leaq 0x74868(%rip), %rdx     # 0xdead6
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x3ab1c
cmpq %rbp, %r12
jbe 0x6a290
leaq 0x7485d(%rip), %rdx     # 0xdeae2
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x3ab1c
movq %r13, %rdi
callq 0x13da9
movq %rax, %r15
callq 0xbff0
movq %rax, %r13
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %rbp, %r8
movq %r13, %r9
callq 0x890d4
movl %eax, %ebp
movq %r15, %rdi
callq 0x152db
testl %ebp, %ebp
je 0x6a2de
movq %r14, %rdi
movq %r13, %rsi
callq 0x88ba4
movl %eax, %ebx
jmp 0x6a309
movq %r13, %rdi
callq 0xc291
movq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x38431
movq 0x8(%rsp), %rdi
leaq 0x749d3(%rip), %rsi     # 0xdecd2
movl $0x8b, %edx
callq 0xd249
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc3c97(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5fd3b(%rip), %rsi     # 0xca066
leaq 0x6c6c4(%rip), %rdx     # 0xd69f6
leaq 0x749fa(%rip), %rcx     # 0xded33
leaq 0x74992(%rip), %r8      # 0xdecd2
pushq $0x7a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_get_description
static int region_mapping_lua_get_description(lua_State *L)
{
  GtRegionMapping **region_mapping;
  GtError *err;
  GtStr *seqidstr, *descstr = NULL;
  const char *seqid;
  int had_err = 0;
  gt_assert(L);
  region_mapping = check_region_mapping(L, 1);
  seqid = luaL_checkstring(L, 2);
  seqidstr = gt_str_new_cstr(seqid);
  descstr = gt_str_new();
  err = gt_error_new();
  had_err = gt_region_mapping_get_description(*region_mapping, descstr,
                                              seqidstr, err);
  gt_str_delete(seqidstr);
  if (had_err)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  lua_pushstring(L, gt_str_get(descstr));
  gt_str_delete(descstr);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6a40f
movq %rdi, %rbx
leaq 0x746d6(%rip), %rdx     # 0xdea44
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r12
pushq $0x2
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3adee
movq %rax, %rdi
callq 0x13da9
movq %rax, %r13
callq 0x13d5c
movq %rax, %r14
callq 0xbff0
movq %rax, %r15
movq (%r12), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x89c8f
movl %eax, %ebp
movq %r13, %rdi
callq 0x152db
testl %ebp, %ebp
je 0x6a3da
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x88ba4
movq %r15, %rdi
callq 0xc291
movq %r14, %rdi
callq 0x143d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x38431
movq %r14, %rdi
callq 0x152db
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc3ba2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5fc46(%rip), %rsi     # 0xca066
leaq 0x6c5cf(%rip), %rdx     # 0xd69f6
leaq 0x74925(%rip), %rcx     # 0xded53
leaq 0x7489d(%rip), %r8      # 0xdecd2
movl $0x96, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_get_md5_fingerprint
static int region_mapping_lua_get_md5_fingerprint(lua_State *L)
{
  GtRegionMapping **region_mapping;
  GtError *err;
  GtStr *seqidstr;
  GtRange *rng = NULL;
  GtUword offset;
  const char *md5 = NULL, *seqid;
  gt_assert(L);
  region_mapping = check_region_mapping(L, 1);
  seqid = luaL_checkstring(L, 2);
  if (lua_gettop(L) == 3)
    rng = check_range(L, 3);
  seqidstr = gt_str_new_cstr(seqid);
  err = gt_error_new();
  md5 = gt_region_mapping_get_md5_fingerprint(*region_mapping, seqidstr,
                                              rng, &offset, err);
  gt_str_delete(seqidstr);
  if (!md5)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  lua_pushstring(L, md5);
  lua_pushnumber(L, offset);
  return 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6a539
movq %rdi, %rbx
leaq 0x745df(%rip), %rdx     # 0xdea44
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
xorl %r15d, %r15d
pushq $0x2
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r12
movq %rbx, %rdi
callq 0x377ed
cmpl $0x3, %eax
jne 0x6a4a7
leaq 0x743e8(%rip), %rdx     # 0xde881
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq %rax, %r15
movq %r12, %rdi
callq 0x13da9
movq %rax, %r13
callq 0xbff0
movq %rax, %r12
movq (%r14), %rdi
movq %rsp, %rcx
movq %r13, %rsi
movq %r15, %rdx
movq %rax, %r8
callq 0x8a084
movq %rax, %r14
movq %r13, %rdi
callq 0x152db
testq %r14, %r14
je 0x6a51b
movq %r12, %rdi
callq 0xc291
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38431
movsd (%rsp), %xmm1
unpcklps 0x5ff83(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x5ff8b(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
jmp 0x6a528
movq %rbx, %rdi
movq %r12, %rsi
callq 0x88ba4
movl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc3a78(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5fb1c(%rip), %rsi     # 0xca066
leaq 0x6c4a5(%rip), %rdx     # 0xd69f6
leaq 0x7481e(%rip), %rcx     # 0xded76
leaq 0x74773(%rip), %r8      # 0xdecd2
movl $0xaf, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_new_seqfile_matchdesc
static int region_mapping_lua_new_seqfile_matchdesc(lua_State *L)
{
  const char *seqfilename;
  GtStrArray *seqfile;
  GtRegionMapping **region_mapping;
  gt_assert(L);
  seqfilename = luaL_checkstring(L, 1);
  region_mapping = lua_newuserdata(L, sizeof (GtRegionMapping*));
  gt_assert(region_mapping);
  seqfile = gt_str_array_new();
  gt_str_array_add_cstr(seqfile, seqfilename);
  /* XXX: make second and third parameter available */
  *region_mapping = gt_region_mapping_new_seqfiles(seqfile, true, false);
  gt_str_array_delete(seqfile);
  luaL_getmetatable(L, REGION_MAPPING_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6a607
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x6a631
movq %rax, %r14
callq 0x1532c
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x15407
pushq $0x1
popq %rbp
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x88e55
movq %rax, (%r14)
movq %r12, %rdi
callq 0x1583a
leaq 0x74460(%rip), %rdx     # 0xdea44
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xc39aa(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5fa4e(%rip), %rsi     # 0xca066
leaq 0x6c3d7(%rip), %rdx     # 0xd69f6
leaq 0x74804(%rip), %rcx     # 0xdee2a
leaq 0x746a5(%rip), %r8      # 0xdecd2
pushq $0x20
jmp 0x6a659
movq 0xc3980(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5fa24(%rip), %rsi     # 0xca066
leaq 0x89d5b(%rip), %rdx     # 0xf43a4
leaq 0x747da(%rip), %rcx     # 0xdee2a
leaq 0x7467b(%rip), %r8      # 0xdecd2
pushq $0x23
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_new_seqfile_matchdescstart
static int region_mapping_lua_new_seqfile_matchdescstart(lua_State *L)
{
  const char *seqfilename;
  GtStrArray *seqfile;
  GtRegionMapping **region_mapping;
  gt_assert(L);
  seqfilename = luaL_checkstring(L, 1);
  region_mapping = lua_newuserdata(L, sizeof (GtRegionMapping*));
  gt_assert(region_mapping);
  seqfile = gt_str_array_new();
  gt_str_array_add_cstr(seqfile, seqfilename);
  /* XXX: make second and third parameter available */
  *region_mapping = gt_region_mapping_new_seqfiles(seqfile, true, false);
  gt_region_mapping_enable_match_desc_start(*region_mapping);
  gt_str_array_delete(seqfile);
  luaL_getmetatable(L, REGION_MAPPING_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6a6fe
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x6a728
movq %rax, %r14
callq 0x1532c
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x15407
pushq $0x1
popq %rbp
movq %r12, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x88e55
movq %rax, (%r14)
movq %rax, %rdi
callq 0x8904e
movq %r12, %rdi
callq 0x1583a
leaq 0x74369(%rip), %rdx     # 0xdea44
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xc38b3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f957(%rip), %rsi     # 0xca066
leaq 0x6c2e0(%rip), %rdx     # 0xd69f6
leaq 0x74736(%rip), %rcx     # 0xdee53
leaq 0x745ae(%rip), %r8      # 0xdecd2
pushq $0x33
jmp 0x6a750
movq 0xc3889(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f92d(%rip), %rsi     # 0xca066
leaq 0x89c64(%rip), %rdx     # 0xf43a4
leaq 0x7470c(%rip), %rcx     # 0xdee53
leaq 0x74584(%rip), %r8      # 0xdecd2
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/region_mapping_lua.c
// Function: region_mapping_lua_new_seqfile_usedesc
static int region_mapping_lua_new_seqfile_usedesc(lua_State *L)
{
  const char *seqfilename;
  GtStrArray *seqfile;
  GtRegionMapping **region_mapping;
  gt_assert(L);
  seqfilename = luaL_checkstring(L, 1);
  region_mapping = lua_newuserdata(L, sizeof (GtRegionMapping*));
  gt_assert(region_mapping);
  seqfile = gt_str_array_new();
  gt_str_array_add_cstr(seqfile, seqfilename);
  /* XXX: make second and third parameter available */
  *region_mapping = gt_region_mapping_new_seqfiles(seqfile, false, true);
  gt_str_array_delete(seqfile);
  luaL_getmetatable(L, REGION_MAPPING_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6a7e9
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x6a813
movq %rax, %r14
callq 0x1532c
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x15407
pushq $0x1
popq %rbp
movq %r12, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x88e55
movq %rax, (%r14)
movq %r12, %rdi
callq 0x1583a
leaq 0x7427e(%rip), %rdx     # 0xdea44
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xc37c8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f86c(%rip), %rsi     # 0xca066
leaq 0x6c1f5(%rip), %rdx     # 0xd69f6
leaq 0x74679(%rip), %rcx     # 0xdee81
leaq 0x744c3(%rip), %r8      # 0xdecd2
pushq $0x47
jmp 0x6a83b
movq 0xc379e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f842(%rip), %rsi     # 0xca066
leaq 0x89b79(%rip), %rdx     # 0xf43a4
leaq 0x7464f(%rip), %rcx     # 0xdee81
leaq 0x74499(%rip), %r8      # 0xdecd2
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/score_matrix_lua.c
// Function: gt_lua_open_score_matrix
int gt_lua_open_score_matrix(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, SCOREMATRIX_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, score_matrix_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, score_matrix_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", score_matrix_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 0x6a90f
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x74674(%rip), %rsi     # 0xdeede
movq %rbx, %rdi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x6c9fa(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f41
leaq 0x6c338(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xcc(%rip), %rsi        # 0x6a975
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0xc242b(%rip), %rdx     # 0x12ccf0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
leaq 0x7f996(%rip), %rsi     # 0xea277
leaq 0xc2448(%rip), %rdx     # 0x12cd30
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x6a93d
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0xc36a2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f746(%rip), %rsi     # 0xca066
leaq 0x6c0cf(%rip), %rdx     # 0xd69f6
leaq 0x7457a(%rip), %rcx     # 0xdeea8
leaq 0x7458c(%rip), %r8      # 0xdeec1
movl $0x83, %r9d
jmp 0x6a969
movq 0xc3674(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f718(%rip), %rsi     # 0xca066
leaq 0x73486(%rip), %rdx     # 0xddddb
leaq 0x7454c(%rip), %rcx     # 0xdeea8
leaq 0x7455e(%rip), %r8      # 0xdeec1
movl $0x94, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/score_matrix_lua.c
// Function: score_matrix_lua_get_dimension
static int score_matrix_lua_get_dimension(lua_State *L)
{
  GtScoreMatrix **sm;
  unsigned int dimension;
  sm = check_score_matrix(L, 1);
  dimension = gt_score_matrix_get_dimension(*sm);
  lua_pushinteger(L, dimension);
  return 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x74540(%rip), %rdx     # 0xdeede
pushq $0x1
popq %rbp
movl %ebp, %esi
callq 0x3ae77
movq (%rax), %rdi
callq 0x85285
movl %eax, %esi
movq %rbx, %rdi
callq 0x38270
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/score_matrix_lua.c
// Function: score_matrix_lua_get_score
static int score_matrix_lua_get_score(lua_State *L)
{
  GtScoreMatrix **sm;
  int idx1, idx2;
  int score;
  sm = check_score_matrix(L, 1);
  idx1 = luaL_checkint(L, 2);
  idx2 = luaL_checkint(L, 3);
  luaL_argcheck(L, idx1 >= 0, 2, "idx1 too small");
  luaL_argcheck(L, idx2 >= 0, 3, "idx2 too small");
  luaL_argcheck(L, idx1 < gt_score_matrix_get_dimension(*sm), 2,
                "idx1 too large");
  luaL_argcheck(L, idx2 < gt_score_matrix_get_dimension(*sm), 3,
                "idx2 too large");
  score = gt_score_matrix_get_score(*sm, idx1, idx2);
  lua_pushinteger(L, score);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x74509(%rip), %rdx     # 0xdeede
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
testl %r15d, %r15d
jns 0x6aa13
leaq 0x744ef(%rip), %rdx     # 0xdeef7
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
testl %r12d, %r12d
jns 0x6aa2a
leaq 0x744e7(%rip), %rdx     # 0xdef06
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
callq 0x85285
cmpl %r15d, %eax
ja 0x6aa49
leaq 0x744d7(%rip), %rdx     # 0xdef15
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
callq 0x85285
cmpl %r12d, %eax
ja 0x6aa68
leaq 0x744c7(%rip), %rdx     # 0xdef24
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
movq (%r14), %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0x852c7
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x38270
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/score_matrix_lua.c
// Function: score_matrix_lua_new_read_protein
static int score_matrix_lua_new_read_protein(lua_State *L)
{
  GtScoreMatrix **sm;
  const char *path;
  GtError *err;
  gt_assert(L);
  path = luaL_checkstring(L, 1);
  sm = lua_newuserdata(L, sizeof (GtScoreMatrix*));
  gt_assert(sm);
  err = gt_error_new();
  if (!(*sm = gt_score_matrix_new_read_protein(path, err)))
    return gt_lua_error(L, err); /* handle error */
  gt_error_delete(err);
  gt_assert(*sm);
  luaL_getmetatable(L, SCOREMATRIX_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6ab5f
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r15
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x6ab89
movq %rax, %r14
callq 0xbff0
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x84a86
movq %rax, (%r14)
testq %rax, %rax
je 0x6ab49
movq %r12, %rdi
callq 0xc291
cmpq $0x0, (%r14)
je 0x6abb3
leaq 0x743bc(%rip), %rdx     # 0xdeede
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 %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x88ba4
movq 0xc3452(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f4f6(%rip), %rsi     # 0xca066
leaq 0x6be7f(%rip), %rdx     # 0xd69f6
leaq 0x743b5(%rip), %rcx     # 0xdef33
leaq 0x7433c(%rip), %r8      # 0xdeec1
pushq $0x21
jmp 0x6abdb
movq 0xc3428(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f4cc(%rip), %rsi     # 0xca066
leaq 0x743b5(%rip), %rdx     # 0xdef56
leaq 0x7438b(%rip), %rcx     # 0xdef33
leaq 0x74312(%rip), %r8      # 0xdeec1
pushq $0x24
jmp 0x6abdb
movq 0xc33fe(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f4a2(%rip), %rsi     # 0xca066
leaq 0x7438a(%rip), %rdx     # 0xdef55
leaq 0x74361(%rip), %rcx     # 0xdef33
leaq 0x742e8(%rip), %r8      # 0xdeec1
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/score_matrix_lua.c
// Function: score_matrix_lua_new_read
static int score_matrix_lua_new_read(lua_State *L)
{
  GtScoreMatrix **sm;
  GtAlphabet **alpha;
  const char *path;
  GtError *err;
  gt_assert(L);
  path = luaL_checkstring(L, 1);
  alpha = check_alphabet(L, 2);
  sm = lua_newuserdata(L, sizeof (GtScoreMatrix*));
  gt_assert(sm);
  err = gt_error_new();
  if (!(*sm = gt_score_matrix_new_read(path, *alpha, err)))
    return gt_lua_error(L, err); /* handle error */
  gt_error_delete(err);
  gt_assert(*sm);
  luaL_getmetatable(L, SCOREMATRIX_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x6aca8
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r14
leaq 0x74361(%rip), %rdx     # 0xdef73
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 0x6acd2
movq %rax, %r15
callq 0xbff0
movq %rax, %r13
movq (%r12), %rsi
movq %r14, %rdi
movq %rax, %rdx
callq 0x851c5
movq %rax, (%r15)
testq %rax, %rax
je 0x6ac94
movq %r13, %rdi
callq 0xc291
cmpq $0x0, (%r15)
je 0x6acfc
leaq 0x7426f(%rip), %rdx     # 0xdeede
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 %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r13, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x88ba4
movq 0xc3309(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f3ad(%rip), %rsi     # 0xca066
leaq 0x6bd36(%rip), %rdx     # 0xd69f6
leaq 0x74292(%rip), %rcx     # 0xdef59
leaq 0x741f3(%rip), %r8      # 0xdeec1
pushq $0x35
jmp 0x6ad24
movq 0xc32df(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f383(%rip), %rsi     # 0xca066
leaq 0x7426c(%rip), %rdx     # 0xdef56
leaq 0x74268(%rip), %rcx     # 0xdef59
leaq 0x741c9(%rip), %r8      # 0xdeec1
pushq $0x39
jmp 0x6ad24
movq 0xc32b5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f359(%rip), %rsi     # 0xca066
leaq 0x74241(%rip), %rdx     # 0xdef55
leaq 0x7423e(%rip), %rcx     # 0xdef59
leaq 0x7419f(%rip), %r8      # 0xdeec1
pushq $0x3e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/stream_evaluator_lua.c
// Function: gt_lua_open_stream_evaluator
int gt_lua_open_stream_evaluator(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, STREAM_EVALUATOR_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, stream_evaluator_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, stream_evaluator_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", stream_evaluator_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 0x6adf7
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x74274(%rip), %rsi     # 0xdefc6
movq %rbx, %rdi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x6c512(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f41
leaq 0x6be50(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xc6(%rip), %rsi        # 0x6ae57
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0xc1fb3(%rip), %rdx     # 0x12cd60
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
leaq 0x7f4ae(%rip), %rsi     # 0xea277
leaq 0xc1fc0(%rip), %rdx     # 0x12cd90
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x6ae21
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0xc31ba(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f25e(%rip), %rsi     # 0xca066
leaq 0x6bbe7(%rip), %rdx     # 0xd69f6
leaq 0x74172(%rip), %rcx     # 0xdef88
leaq 0x74188(%rip), %r8      # 0xdefa5
pushq $0x62
jmp 0x6ae49
movq 0xc3190(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f234(%rip), %rsi     # 0xca066
leaq 0x72fa2(%rip), %rdx     # 0xddddb
leaq 0x74148(%rip), %rcx     # 0xdef88
leaq 0x7415e(%rip), %r8      # 0xdefa5
pushq $0x73
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/stream_evaluator_lua.c
// Function: stream_evaluator_lua_evaluate
static int stream_evaluator_lua_evaluate(lua_State *L)
{
  GtStreamEvaluator **stream_evaluator;
  GtNodeVisitor **genome_visitor;
  GtError *err;
  stream_evaluator = check_stream_evaluator(L);
  if (lua_gettop(L) >= 2) {
    genome_visitor = check_genome_visitor(L, 2);
  }
  else
    genome_visitor = NULL;
  err = gt_error_new();
  if (gt_stream_evaluator_evaluate(*stream_evaluator, false, false, false,
                                   genome_visitor ? *genome_visitor : NULL,
                                   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 0x74141(%rip), %rdx     # 0xdefc6
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
movq %rbx, %rdi
callq 0x377ed
cmpl $0x2, %eax
jl 0x6aeb4
leaq 0x73a2e(%rip), %rdx     # 0xde8d2
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq %rax, %r12
jmp 0x6aeb7
xorl %r12d, %r12d
callq 0xbff0
movq %rax, %r14
movq (%r15), %rdi
testq %r12, %r12
je 0x6aecd
movq (%r12), %r8
jmp 0x6aed0
xorl %r8d, %r8d
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r9
callq 0x8b3bd
testl %eax, %eax
je 0x6aef8
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x88ba4
movq %r14, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/stream_evaluator_lua.c
// Function: stream_evaluator_lua_new
static int stream_evaluator_lua_new(lua_State *L)
{
  GtStreamEvaluator **stream_evaluator;
  GtNodeStream **reality_stream, **prediction_stream;
  reality_stream = check_genome_stream(L, 1);
  prediction_stream = check_genome_stream(L, 2);
  stream_evaluator = lua_newuserdata(L, sizeof (GtStreamEvaluator*));
  *stream_evaluator = gt_stream_evaluator_new(*reality_stream,
                                              *prediction_stream,
                                              true, false, 0);
  luaL_getmetatable(L, STREAM_EVALUATOR_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x740b9(%rip), %r15     # 0xdeff8
pushq $0x1
popq %rbx
movl %ebx, %esi
movq %r15, %rdx
callq 0x3ae77
movq %rax, %r12
pushq $0x2
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3ae77
movq %rax, %r15
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x39c01
movq %rax, %r13
movq (%r12), %rdi
movq (%r15), %rsi
movl %ebx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8afec
movq %rax, (%r13)
leaq 0x7403a(%rip), %rdx     # 0xdefc6
movq %r14, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x3914f
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/translate_lua.c
// Function: gt_lua_open_translate
int gt_lua_open_translate(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_register(L, "gt", translate_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 0x6aff9
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x7f2ae(%rip), %rsi     # 0xea277
leaq 0xc1de0(%rip), %rdx     # 0x12cdb0
movq %rbx, %rdi
callq 0x3b11b
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x6b023
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xc2fb8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f05c(%rip), %rsi     # 0xca066
leaq 0x6b9e5(%rip), %rdx     # 0xd69f6
leaq 0x73ffa(%rip), %rcx     # 0xdf012
leaq 0x74009(%rip), %r8      # 0xdf028
pushq $0x4f
jmp 0x6b04b
movq 0xc2f8e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5f032(%rip), %rsi     # 0xca066
leaq 0x72da0(%rip), %rdx     # 0xddddb
leaq 0x73fd0(%rip), %rcx     # 0xdf012
leaq 0x73fdf(%rip), %r8      # 0xdf028
pushq $0x55
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/translate_lua.c
// Function: translate_dna_lua
static int translate_dna_lua(lua_State *L)
{
  int had_err = 0;
  GtStr *protein;
  GtTranslator *tr;
  GtTranslatorStatus status;
  char translated;
  GtError *err;
  unsigned int frame;
  const char *dna = luaL_checkstring(L, 1);
  luaL_argcheck(L, strlen(dna) >= 3, 1,
                "string to translate must at least be one codon");
  protein = gt_str_new();

  err = gt_error_new();
  GtCodonIterator *ci = gt_codon_iterator_simple_new(dna,
                                                     strlen(dna),
                                                     err);
  if (!ci) {
    gt_str_delete(protein);
     return gt_lua_error(L, err);
  }
  tr = gt_translator_new(ci);
  status = gt_translator_next(tr, &translated, &frame, err);
  while (status == GT_TRANSLATOR_OK) {
    if (frame == 0)
      gt_str_append_char(protein, translated);
    status = gt_translator_next(tr, &translated, &frame, err);
  }
  if (status == GT_TRANSLATOR_ERROR)
    had_err = -1;

  if (had_err)
    return gt_lua_error(L, err);
  gt_error_delete(err);

  lua_pushstring(L, gt_str_get(protein));
  gt_str_delete(protein);
  gt_translator_delete(tr);
  gt_codon_iterator_delete(ci);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x3adee
movq %rax, %r13
movq %rax, %rdi
callq 0xb260
cmpq $0x2, %rax
ja 0x6b097
leaq 0x73fc4(%rip), %rdx     # 0xdf050
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x3ab1c
callq 0x13d5c
movq %rax, %r15
callq 0xbff0
movq %rax, %r12
movq %r13, %rdi
callq 0xb260
movq %r13, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x83627
testq %rax, %rax
je 0x6b11e
movq %rax, %r13
movq %rbx, 0x10(%rsp)
movq %rax, %rdi
callq 0x86e46
movq %rax, %rbp
leaq 0xb(%rsp), %rbx
leaq 0xc(%rsp), %r14
movq %rbp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x87367
testl %eax, %eax
jne 0x6b10a
cmpl $0x0, 0xc(%rsp)
jne 0x6b0df
movsbl 0xb(%rsp), %esi
movq %r15, %rdi
callq 0x140b1
jmp 0x6b0df
cmpl $-0x2, %eax
jne 0x6b13f
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x88ba4
jmp 0x6b177
movq %r15, %rdi
callq 0x152db
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
movq %r15, %rdi
callq 0x143d2
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x38431
movq %r15, %rdi
callq 0x152db
movq %rbp, %rdi
callq 0x874ce
movq %r13, %rdi
callq 0x83360
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_compare
int gt_block_compare(const GtBlock *block1, const GtBlock *block2,
                     GT_UNUSED void *data)
{
  GtRange range_a, range_b;
  int ret = 0;
  gt_assert(block1 && block2);
  range_a = gt_block_get_range(block1),
  range_b = gt_block_get_range(block2);
  ret = gt_range_compare(&range_a, &range_b);
  if (ret == 0 && block1 != block2) {
    GtStr *caption1, *caption2;
    caption1 = gt_block_get_caption(block1);
    caption2 = gt_block_get_caption(block2);
    /* blocks do not necessarily have captions. If both have a caption, we
       compare them. If only one block has a caption, this block comes first. */
    if (caption1 && caption2)
      ret = strcmp(gt_str_get(caption1), gt_str_get(caption2));
    else if (caption1)
      ret = -1;
    else if (caption2)
      ret = 1;
  }
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x6b21e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x6b21e
movq %rdi, %r14
movups 0x8(%rdi), %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movups 0x8(%rbx), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
callq 0x5cec8
testl %eax, %eax
je 0x6b1ca
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpq %rbx, %r14
je 0x6b207
movq 0x18(%r14), %rdi
movq 0x18(%rbx), %rbx
testq %rdi, %rdi
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x6b20b
callq 0x143d2
movq %rax, %r14
movq %rbx, %rdi
callq 0x143d2
movq %r14, %rdi
movq %rax, %rsi
callq 0xb880
jmp 0x6b1c2
xorl %eax, %eax
jmp 0x6b1c2
xorl %ecx, %ecx
testq %rbx, %rbx
setne %cl
xorl %eax, %eax
negq %rdi
sbbl %eax, %eax
orl %ecx, %eax
jmp 0x6b1c2
movq 0xc2d93(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5ee37(%rip), %rsi     # 0xca066
leaq 0x73e49(%rip), %rdx     # 0xdf07f
leaq 0x73e53(%rip), %rcx     # 0xdf090
leaq 0x73e5d(%rip), %r8      # 0xdf0a1
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_print
void gt_block_print(const GtBlock* block)
{
  GtUword i;
  gt_assert(block);
  for (i=0;i<gt_array_size(block->elements);i++)
  {
    GtElement *elem;
    elem = gt_element_ref(*(GtElement**) gt_array_get(block->elements, i));
    gt_assert(elem);
    GtRange r = gt_element_get_range(elem);
    printf("%s\t"GT_WU"-"GT_WU"\n", gt_element_get_type(elem),
                           r.start,
                           r.end);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6b3e0
movq %rdi, %rbx
leaq 0x73d9a(%rip), %r14     # 0xdf0da
xorl %r15d, %r15d
movq (%rbx), %rdi
callq 0x4b988
cmpq %rax, %r15
jae 0x6b399
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x6f50d
testq %rax, %rax
je 0x6b3a8
movq %rax, %r12
movq %rax, %rdi
callq 0x6f551
movq %rax, %r13
movq %rdx, %rbp
movq %r12, %rdi
callq 0x6f596
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0xb070
incq %r15
jmp 0x6b343
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc2c09(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5ecad(%rip), %rsi     # 0xca066
leaq 0x6cc73(%rip), %rdx     # 0xd8033
leaq 0x73d04(%rip), %rcx     # 0xdf0cb
leaq 0x73cd3(%rip), %r8      # 0xdf0a1
movl $0x80, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0xc2bd1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5ec75(%rip), %rsi     # 0xca066
leaq 0x74c44(%rip), %rdx     # 0xe003c
leaq 0x73ccc(%rip), %rcx     # 0xdf0cb
leaq 0x73c9b(%rip), %r8      # 0xdf0a1
pushq $0x7b
popq %r9
jmp 0x6b3d4
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_new
GtBlock* gt_block_new(void)
{
  GtBlock *block = gt_calloc(1, sizeof (GtBlock));
  block->elements = gt_array_new(sizeof (GtElement*));
  block->caption = NULL;
  block->show_caption = true;
  block->sorted = false;
  block->strand = GT_STRAND_UNKNOWN;
  block->top_level_feature = NULL;
  return block;
}

// Assembly:
pushq %rbx
leaq 0x73c8d(%rip), %rdx     # 0xdf0a1
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
movl $0x8a, %ecx
callq 0xce9a
movq %rax, %rbx
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, (%rbx)
andq $0x0, 0x18(%rbx)
movw $0x1, 0x28(%rbx)
movl $0x3, 0x2c(%rbx)
andq $0x0, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_new_from_node
GtBlock* gt_block_new_from_node(GtFeatureNode *node)
{
  GtBlock *block;
  gt_assert(node);
  block = gt_block_new();
  block->range = gt_genome_node_get_range((GtGenomeNode*) node);
  block->strand = gt_feature_node_get_strand(node);
  block->type = gt_feature_node_get_type(node);
  if (!gt_feature_node_is_pseudo(node)) {
    block->top_level_feature = (GtFeatureNode*)
                               gt_genome_node_ref((GtGenomeNode*) node);
  }
  return block;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6b4ad
movq %rdi, %rbx
callq 0x6b40c
movq %rax, %r14
movq %rbx, %rdi
callq 0x1c3c4
movq %rax, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rbx, %rdi
callq 0x18f89
movl %eax, 0x2c(%r14)
movq %rbx, %rdi
callq 0x19528
movq %rax, 0x30(%r14)
movq %rbx, %rdi
callq 0x19959
testb %al, %al
jne 0x6b4a2
movq %rbx, %rdi
callq 0x1bec8
movq %rax, 0x38(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xc2b04(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5eba8(%rip), %rsi     # 0xca066
leaq 0x6845b(%rip), %rdx     # 0xd3920
leaq 0x73c1a(%rip), %rcx     # 0xdf0e6
leaq 0x73bce(%rip), %r8      # 0xdf0a1
movl $0x97, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_insert_element
void gt_block_insert_element(GtBlock *block, GtFeatureNode *node)
{
  GtElement *element;
  gt_assert(block && node);
  if (!block->top_level_feature) {
    block->top_level_feature = (GtFeatureNode*)
                               gt_genome_node_ref((GtGenomeNode*) node);
  }
  element = gt_element_new(node);
  /* invalidate sortedness flag because insertion of element at the end
     may break ordering */
  block->sorted = false;
  gt_array_add(block->elements, element);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6b531
movq %rsi, %r14
testq %rsi, %rsi
je 0x6b531
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x6b50c
movq %r14, %rdi
callq 0x1bec8
movq %rax, 0x38(%rbx)
movq %r14, %rdi
callq 0x6f3d4
movq %rsp, %rsi
movq %rax, (%rsi)
movb $0x0, 0x29(%rbx)
movq (%rbx), %rdi
pushq $0x8
popq %rdx
callq 0x4b801
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xc2a80(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5eb24(%rip), %rsi     # 0xca066
leaq 0x73bb4(%rip), %rdx     # 0xdf0fd
leaq 0x73bbb(%rip), %rcx     # 0xdf10b
leaq 0x73b4a(%rip), %r8      # 0xdf0a1
movl $0xa6, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_merge
void gt_block_merge(GtBlock *b1, GtBlock *b2)
{
  unsigned int GT_UNUSED merged_size, i;
  gt_assert(b1 && b2);
  merged_size = gt_block_get_size(b1) + gt_block_get_size(b2);
  for (i=0;i<gt_array_size(b2->elements);i++)
  {
    GtElement *elem;
    elem = gt_element_ref(*(GtElement**) gt_array_get(b2->elements, i));
    gt_assert(elem);
    gt_array_add(b1->elements, elem);
  }
  gt_assert(gt_block_get_size(b1) == merged_size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x6b641
movq %rsi, %r14
testq %rsi, %rsi
je 0x6b641
movq %rdi, %rbx
callq 0x6b69d
movq %rax, %r12
movq %r14, %rdi
callq 0x6b69d
movq %rax, %r15
addq %r12, %r15
xorl %r12d, %r12d
movq %rsp, %r13
pushq $0x8
popq %rbp
movl %r12d, %r12d
movq (%r14), %rdi
callq 0x4b988
cmpq %r12, %rax
jbe 0x6b5ea
movq (%r14), %rdi
movq %r12, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x6f50d
movq %rax, (%rsp)
testq %rax, %rax
je 0x6b609
movq (%rbx), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4b801
incl %r12d
jmp 0x6b5ab
movq %rbx, %rdi
callq 0x6b69d
movl %r15d, %ecx
cmpq %rcx, %rax
jne 0x6b66f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xc29a8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5ea4c(%rip), %rsi     # 0xca066
leaq 0x6ca12(%rip), %rdx     # 0xd8033
leaq 0x73b04(%rip), %rcx     # 0xdf12c
leaq 0x73a72(%rip), %r8      # 0xdf0a1
movl $0xbb, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0xc2970(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5ea14(%rip), %rsi     # 0xca066
leaq 0x73aca(%rip), %rdx     # 0xdf123
leaq 0x73acc(%rip), %rcx     # 0xdf12c
leaq 0x73a3a(%rip), %r8      # 0xdf0a1
movl $0xb5, %r9d
jmp 0x6b635
movq 0xc2942(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5e9e6(%rip), %rsi     # 0xca066
leaq 0x73ab4(%rip), %rdx     # 0xdf13b
leaq 0x73a9e(%rip), %rcx     # 0xdf12c
leaq 0x73a0c(%rip), %r8      # 0xdf0a1
movl $0xbe, %r9d
jmp 0x6b635
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_clone
GtBlock* gt_block_clone(GtBlock *block)
{
  GtBlock* newblock;
  GtUword i;
  gt_assert(block);
  newblock = gt_block_new();
  for (i=0;i<gt_array_size(block->elements);i++)
  {
    GtElement *elem;
    elem = gt_element_ref(*(GtElement**) gt_array_get(block->elements, i));
    gt_assert(elem);
    gt_array_add(newblock->elements, elem);
  }
  gt_assert(gt_block_get_size(newblock) == gt_block_get_size(block));
  newblock->caption = gt_str_ref(block->caption);
  newblock->type = block->type;
  newblock->range.start = block->range.start;
  newblock->range.end = block->range.end;
  newblock->show_caption = block->show_caption;
  newblock->strand = block->strand;
  newblock->top_level_feature = (GtFeatureNode*)
                                gt_genome_node_ref((GtGenomeNode*)
                                                   block->top_level_feature);
  return newblock;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x6b7ef
movq %rdi, %rbx
xorl %r15d, %r15d
callq 0x6b40c
movq %rax, %r14
leaq 0x8(%rsp), %r12
pushq $0x8
popq %r13
movq (%rbx), %rdi
callq 0x4b988
cmpq %rax, %r15
jae 0x6b751
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x4b48e
movq (%rax), %rdi
callq 0x6f50d
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x6b7b7
movq (%r14), %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x4b801
incq %r15
jmp 0x6b714
movq %r14, %rdi
callq 0x6b69d
movq %rax, %r15
movq %rbx, %rdi
callq 0x6b69d
cmpq %rax, %r15
jne 0x6b81d
movq 0x18(%rbx), %rdi
callq 0x146aa
movq %rax, 0x18(%r14)
movq 0x30(%rbx), %rax
movq %rax, 0x30(%r14)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x8(%r14)
movb 0x28(%rbx), %al
movb %al, 0x28(%r14)
movl 0x2c(%rbx), %eax
movl %eax, 0x2c(%r14)
movq 0x38(%rbx), %rdi
callq 0x1bec8
movq %rax, 0x38(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xc27fa(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5e89e(%rip), %rsi     # 0xca066
leaq 0x6c864(%rip), %rdx     # 0xd8033
leaq 0x7398a(%rip), %rcx     # 0xdf160
leaq 0x738c4(%rip), %r8      # 0xdf0a1
movl $0xcb, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0xc27c2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5e866(%rip), %rsi     # 0xca066
leaq 0x74835(%rip), %rdx     # 0xe003c
leaq 0x73952(%rip), %rcx     # 0xdf160
leaq 0x7388c(%rip), %r8      # 0xdf0a1
movl $0xc5, %r9d
jmp 0x6b7e3
movq 0xc2794(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x5e838(%rip), %rsi     # 0xca066
leaq 0x7393a(%rip), %rdx     # 0xdf16f
leaq 0x73924(%rip), %rcx     # 0xdf160
leaq 0x7385e(%rip), %r8      # 0xdf0a1
movl $0xce, %r9d
jmp 0x6b7e3