LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x89d13
movq %rdi, %rbx
leaq 0x6baac(%rip), %rdx     # 0xf56e4
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r12
movq %rbx, %rdi
callq 0x56afc
cmpl $0x3, %eax
jne 0x89c7e
leaq 0x6b8b3(%rip), %rdx     # 0xf5521
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a67c
movq %rax, %r15
movq %r12, %rdi
callq 0x3b785
movq %rax, %r13
callq 0x34f04
movq %rax, %r12
movq (%r14), %rdi
leaq 0x8(%rsp), %rcx
movq %r13, %rsi
movq %r15, %rdx
movq %rax, %r8
callq 0xa8bf7
movq %rax, %r14
movq %r13, %rdi
callq 0x3c87b
testq %r14, %r14
je 0x89cfa
movq %r12, %rdi
callq 0x35085
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5790a
movsd 0x8(%rsp), %xmm1
unpcklps 0x577a9(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x577b1(%rip), %xmm1    # 0xe1490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x57718
movl $0x2, %eax
jmp 0x89d05
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa7d4a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x20953
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x89dbc
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0x89dc1
movq %rax, %r14
callq 0x3c8cc
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x3c9a5
movq %r12, %rdi
movl $0x1, %esi
xorl %edx, %edx
callq 0xa7f25
movq %rax, (%r14)
movq %r12, %rdi
callq 0x3cc00
leaq 0x6b953(%rip), %rdx     # 0xf56e4
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x209c3
callq 0x2098c
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x89f06
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0x89f0b
movq %rax, %r14
callq 0x3c8cc
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x3c9a5
movq %r12, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xa7f25
movq %rax, (%r14)
movq %r12, %rdi
callq 0x3cc00
leaq 0x6b809(%rip), %rdx     # 0xf56e4
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x20a9f
callq 0x20a68
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0x89fdc
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x6bc51(%rip), %rsi     # 0xf5b7e
movq %rbx, %rdi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x6438d(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x63ccd(%rip), %rsi     # 0xedc2a
movq %rbx, %rdi
callq 0x5790a
leaq 0x7a(%rip), %rsi        # 0x89fe6
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0xc5d86(%rip), %rdx     # 0x14fd10
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
leaq 0x77053(%rip), %rsi     # 0x100ffb
leaq 0xc5da1(%rip), %rdx     # 0x14fd50
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x89fe1
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20b0f
callq 0x20ad6
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x6bb6f(%rip), %rdx     # 0xf5b7e
movl $0x1, %esi
callq 0x5a67c
movq (%rax), %rdi
callq 0xa4f8a
movl %eax, %esi
movq %rbx, %rdi
callq 0x5772d
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6bb3a(%rip), %rdx     # 0xf5b7e
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a844
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a844
movq %rax, %r12
testl %r15d, %r15d
jns 0x8a08a
leaq 0x6bb1a(%rip), %rdx     # 0xf5b97
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
testl %r12d, %r12d
jns 0x8a0a3
leaq 0x6bb10(%rip), %rdx     # 0xf5ba6
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
movq (%r14), %rdi
callq 0xa4f8a
cmpl %r15d, %eax
ja 0x8a0c4
leaq 0x6bafe(%rip), %rdx     # 0xf5bb5
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a2e1
movq (%r14), %rdi
callq 0xa4f8a
cmpl %r12d, %eax
ja 0x8a0e5
leaq 0x6baec(%rip), %rdx     # 0xf5bc4
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5a2e1
movq (%r14), %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0xa4f99
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x5772d
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/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 0x8a1e0
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0x8a1e5
movq %rax, %r14
callq 0x34f04
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xa4925
movq %rax, (%r14)
testq %rax, %rax
je 0x8a1ca
movq %r12, %rdi
callq 0x35085
cmpq $0x0, (%r14)
je 0x8a1ea
leaq 0x6b9df(%rip), %rdx     # 0xf5b7e
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa7d4a
callq 0x20bb6
callq 0x20b7f
callq 0x20b48
// File: /workspace/github_c_makefile_star2_O3/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 0x8a2b0
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r15
leaq 0x6b9f9(%rip), %rdx     # 0xf5c13
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a67c
movq %rax, %r12
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
testq %rax, %rax
je 0x8a2b5
movq %rax, %r14
callq 0x34f04
movq %rax, %r13
movq (%r12), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0xa4f26
movq %rax, (%r14)
testq %rax, %rax
je 0x8a29c
movq %r13, %rdi
callq 0x35085
cmpq $0x0, (%r14)
je 0x8a2ba
leaq 0x6b90b(%rip), %rdx     # 0xf5b7e
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
popq %rbx
popq %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 0xa7d4a
callq 0x20c5b
callq 0x20c24
callq 0x20bed
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
testq %rdi, %rdi
je 0x8a38c
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x6b989(%rip), %rsi     # 0xf5c66
movq %rbx, %rdi
callq 0x5a609
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x56f7b
leaq 0x63fdd(%rip), %rdx     # 0xee2d6
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x584c8
leaq 0x6391d(%rip), %rsi     # 0xedc2a
movq %rbx, %rdi
callq 0x5790a
leaq 0x7a(%rip), %rsi        # 0x8a396
movq %rbx, %rdi
xorl %edx, %edx
callq 0x57d08
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x582b2
leaq 0xc5a46(%rip), %rdx     # 0x14fd80
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
leaq 0x76ca3(%rip), %rsi     # 0x100ffb
leaq 0xc5a51(%rip), %rdx     # 0x14fdb0
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x8a391
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20cc9
callq 0x20c92
// File: /workspace/github_c_makefile_star2_O3/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 0x6b8a0(%rip), %rdx     # 0xf5c66
movl $0x1, %esi
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
callq 0x56afc
cmpl $0x1, %eax
jle 0x8a40d
leaq 0x6b18b(%rip), %rdx     # 0xf5572
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5a67c
movq %rax, %r12
callq 0x34f04
movq %rax, %r14
movq (%r15), %rdi
testq %r12, %r12
je 0x8a418
movq (%r12), %r8
jmp 0x8a41b
callq 0x34f04
movq %rax, %r14
movq (%r15), %rdi
xorl %r8d, %r8d
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r9
callq 0xa9adc
testl %eax, %eax
je 0x8a443
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa7d4a
movq %r14, %rdi
callq 0x35085
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/gtlua/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6b80d(%rip), %r14     # 0xf5c98
movl $0x1, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5a67c
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x5924a
movq %rax, %r12
movq (%r15), %rdi
movq (%r14), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xa96ec
movq %rax, (%r12)
leaq 0x6b788(%rip), %rdx     # 0xf5c66
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x57f56
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x586d6
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0x8a559
movq %rdi, %rbx
callq 0x56afc
movl %eax, %ebp
leaq 0x76ad6(%rip), %rsi     # 0x100ffb
leaq 0xc58a4(%rip), %rdx     # 0x14fdd0
movq %rbx, %rdi
callq 0x5a9b5
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x56b09
movq %rbx, %rdi
callq 0x56afc
cmpl %ebp, %eax
jne 0x8a55e
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20d37
callq 0x20d00
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
xorl %edx, %edx
callq 0x5a5dd
movq %rax, %r12
movq %rax, %rdi
callq 0xb260
cmpq $0x2, %rax
ja 0x8a5a5
leaq 0x6b758(%rip), %rdx     # 0xf5cf0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5a2e1
callq 0x3b728
movq %rax, %r14
callq 0x34f04
movq %rax, %r15
movq %r12, %rdi
callq 0xb260
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xa393d
testq %rax, %rax
je 0x8a62c
movq %rax, %r12
movq %rbx, 0x10(%rsp)
movq %rax, %rdi
callq 0xa64b3
movq %rax, %r13
leaq 0xb(%rsp), %rbp
leaq 0xc(%rsp), %rbx
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0xa6812
testl %eax, %eax
jne 0x8a618
cmpl $0x0, 0xc(%rsp)
jne 0x8a5ed
movsbl 0xb(%rsp), %esi
movq %r14, %rdi
callq 0x3b9df
jmp 0x8a5ed
cmpl $-0x2, %eax
jne 0x8a64d
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xa7d4a
jmp 0x8a687
movq %r14, %rdi
callq 0x3c87b
movq %rbx, %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa7d4a
movq %r15, %rdi
callq 0x35085
movq %r14, %rdi
callq 0x3bb5d
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x5790a
movq %r14, %rdi
callq 0x3c87b
movq %r13, %rdi
callq 0xa68f6
movq %r12, %rdi
callq 0xa374e
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x8a72e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x8a72e
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 0x7e09c
testl %eax, %eax
je 0x8a6da
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpq %rbx, %r14
je 0x8a717
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 0x8a71b
callq 0x3bb5d
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bb5d
movq %r14, %rdi
movq %rax, %rsi
callq 0xb890
jmp 0x8a6d2
xorl %eax, %eax
jmp 0x8a6d2
xorl %ecx, %ecx
testq %rbx, %rbx
setne %cl
xorl %eax, %eax
negq %rdi
sbbl %eax, %eax
orl %ecx, %eax
jmp 0x8a6d2
callq 0x20d6e
// File: /workspace/github_c_makefile_star2_O3/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 0x8a800
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6f310
testq %rax, %rax
je 0x8a7ec
leaq 0x6b5e5(%rip), %r14     # 0xf5d7a
xorl %r15d, %r15d
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x8e146
testq %rax, %rax
je 0x8a7fb
movq %rax, %r12
movq %rax, %rdi
callq 0x8e159
movq %rax, %r13
movq %rdx, %rbp
movq %r12, %rdi
callq 0x8e16d
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0xb070
incq %r15
movq (%rbx), %rdi
callq 0x6f310
cmpq %rax, %r15
jb 0x8a798
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20e4e
callq 0x20e87
// File: /workspace/github_c_makefile_star2_O3/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 0x6b534(%rip), %rdx     # 0xf5d41
movl $0x1, %edi
movl $0x48, %esi
movl $0x8a, %ecx
callq 0x359a6
movq %rax, %rbx
movl $0x8, %edi
callq 0x6ef7c
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movw $0x1, 0x28(%rbx)
movl $0x3, 0x2c(%rbx)
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8a8ac
movq %rdi, %rbx
callq 0x8a805
movq %rax, %r14
movq %rbx, %rdi
callq 0x415e5
movq %rax, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rbx, %rdi
callq 0x3f462
movl %eax, 0x2c(%r14)
movq %rbx, %rdi
callq 0x3f914
movq %rax, 0x30(%r14)
movq %rbx, %rdi
callq 0x3faf4
testb %al, %al
jne 0x8a8a1
movq %rbx, %rdi
callq 0x4130c
movq %rax, 0x38(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x20ebe
// File: /workspace/github_c_makefile_star2_O3/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 0x8a8ff
movq %rsi, %r14
testq %rsi, %rsi
je 0x8a8ff
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x8a8d8
movq %r14, %rdi
callq 0x4130c
movq %rax, 0x38(%rbx)
movq %r14, %rdi
callq 0x8e084
movq %rsp, %rsi
movq %rax, (%rsi)
movb $0x0, 0x29(%rbx)
movq (%rbx), %rdi
movl $0x8, %edx
callq 0x6f240
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x20ef7
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
testq %rdi, %rdi
je 0x8a9c2
movq %rsi, %r14
testq %rsi, %rsi
je 0x8a9c2
movq %rdi, %rbx
callq 0x8a9cc
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x8a9cc
movq %rax, %r15
movq (%r14), %rdi
callq 0x6f310
testq %rax, %rax
je 0x8a999
movl $0x1, %r12d
xorl %ebp, %ebp
leaq 0x10(%rsp), %r13
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x8e146
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x8a9bd
movq (%rbx), %rdi
movl $0x8, %edx
movq %r13, %rsi
callq 0x6f240
movl %r12d, %ebp
movq (%r14), %rdi
callq 0x6f310
incl %r12d
cmpq %rbp, %rax
ja 0x8a959
addq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0x8a9cc
movl %r15d, %ecx
cmpq %rcx, %rax
jne 0x8a9c7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20f69
callq 0x20f30
callq 0x20fa2
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8aab7
movq %rdi, %rbx
callq 0x8a805
movq %rax, %r14
movq (%rbx), %rdi
callq 0x6f310
testq %rax, %rax
je 0x8aa52
xorl %r15d, %r15d
movq %rsp, %r12
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x8e146
movq %rax, (%rsp)
testq %rax, %rax
je 0x8aab2
movq (%r14), %rdi
movl $0x8, %edx
movq %r12, %rsi
callq 0x6f240
incq %r15
movq (%rbx), %rdi
callq 0x6f310
cmpq %rax, %r15
jb 0x8aa12
movq %r14, %rdi
callq 0x8a9cc
movq %rax, %r15
movq %rbx, %rdi
callq 0x8a9cc
cmpq %rax, %r15
jne 0x8aabc
movq 0x18(%rbx), %rdi
callq 0x3bcaf
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 0x4130c
movq %rax, 0x38(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x21014
callq 0x21086
callq 0x2104d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_has_only_one_fullsize_element
bool gt_block_has_only_one_fullsize_element(const GtBlock *block)
{
  bool ret = false;
  GtUword bsize;
  gt_assert(block);
  bsize = gt_array_size(block->elements);
  if (bsize == 1) {
    GtRange elem_range, block_range;
    gt_assert(*(GtElement**) gt_array_get(block->elements, 0) ==
              *(GtElement**) gt_array_get(block->elements, bsize-1));
    elem_range = gt_element_get_range(*(GtElement**)
                                             gt_array_get(block->elements, 0));
    block_range = gt_block_get_range(block);
    ret = (gt_range_compare(&block_range, &elem_range) == 0);
  }
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x8ab74
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6f310
cmpq $0x1, %rax
jne 0x8ab6a
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x6f037
movq (%rax), %r14
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x6f037
cmpq (%rax), %r14
jne 0x8ab79
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x6f037
movq (%rax), %rdi
callq 0x8e159
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movups 0x8(%rbx), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
callq 0x7e09c
testl %eax, %eax
sete %al
jmp 0x8ab6c
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x211a3
callq 0x2116a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_sketch
int gt_block_sketch(GtBlock *block, GtCanvas *canvas, GtError *err)
{
  int had_err = 0;
  GtUword i;
  gt_assert(block && canvas && err);
  /* if resulting block was too short,
     do not traverse this feature tree further */
  had_err = gt_canvas_visit_block(canvas, block, err);
  if (had_err)
  {
    if (had_err == 1)  /* 'magic' value */
      return 0;
    else
      return had_err;
  } /* we have in any case returned if had_err was set */
  if (!block->sorted)
  {
    GtStyle *sty = gt_canvas_get_style(canvas);
    /* sort elements if they have changed since last sketch operation */
    gt_array_sort_with_data(block->elements, elemcmp, sty);
    block->sorted = true;
  }
  /* delegate sketch request to elements */
  for (i=0;i<gt_array_size(block->elements);i++) {
     GtElement *elem = *(GtElement**) gt_array_get(block->elements, i);
     had_err = gt_element_sketch(elem, canvas, err);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x8ae4e
movq %rsi, %r14
testq %rsi, %rsi
je 0x8ae4e
movq %rdx, %rbx
testq %rdx, %rdx
je 0x8ae4e
movq %rdi, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4bf85
xorl %ebp, %ebp
testl %eax, %eax
je 0x8ade2
cmpl $0x1, %eax
je 0x8ae43
movl %eax, %ebp
jmp 0x8ae43
cmpb $0x0, 0x29(%r15)
jne 0x8ae08
movq %r14, %rdi
callq 0x4bfe8
movq (%r15), %rdi
leaq 0x58(%rip), %rsi        # 0x8ae53
movq %rax, %rdx
callq 0x6f3a9
movb $0x1, 0x29(%r15)
movq (%r15), %rdi
callq 0x6f310
testq %rax, %rax
je 0x8ae43
xorl %r12d, %r12d
movq (%r15), %rdi
movq %r12, %rsi
callq 0x6f037
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8e19a
movl %eax, %ebp
incq %r12
movq (%r15), %rdi
callq 0x6f310
cmpq %rax, %r12
jb 0x8ae18
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x213a4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/block.c
// Function: elemcmp
static int elemcmp(const void *a, const void *b, void *data)
{
  const char *type_a, *type_b;
  double zindex_a = GT_UNDEF_DOUBLE, zindex_b= GT_UNDEF_DOUBLE;
  GtStyle *sty = (GtStyle*) data;
  GtElement *elem_a = *(GtElement**) a;
  GtElement *elem_b = *(GtElement**) b;

  type_a = gt_element_get_type(elem_a);
  type_b = gt_element_get_type(elem_b);

  /* same types are equal, no further action needed */
  if (type_a == type_b)
    return 0;
  /* if not, then get z-index from style */
  if (sty)
  {
    (void) gt_style_get_num(sty, type_a, "z_index", &zindex_a, NULL, NULL);
    (void) gt_style_get_num(sty, type_b, "z_index", &zindex_b, NULL, NULL);
  }
  /* only one is set -> put types with set z-indices always on top of others*/
  if (zindex_a == GT_UNDEF_DOUBLE && zindex_b != GT_UNDEF_DOUBLE)
    return -1;
  if (zindex_b == GT_UNDEF_DOUBLE && zindex_a != GT_UNDEF_DOUBLE)
    return 1;
  /* none is set, fall back to default alphabetic ordering */
  if (zindex_a == GT_UNDEF_DOUBLE && zindex_b == GT_UNDEF_DOUBLE)
  {
    if (strcmp(type_a, type_b) < 0)
      return 1;
    return -1;
  }
  /* both z-indices are set */
  if (gt_double_equals_double(zindex_a, zindex_b))
    return 0;
  if (gt_double_smaller_double(zindex_a, zindex_b))
    return -1;
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq (%rdi), %rdi
movq (%rsi), %r14
callq 0x8e16d
movq %rax, %rbx
movq %r14, %rdi
callq 0x8e16d
movq %rax, %r14
xorl %eax, %eax
cmpq %r14, %rbx
je 0x8af9a
testq %r15, %r15
je 0x8af48
leaq 0x6b38e(%rip), %r12     # 0xf623a
leaq 0x10(%rsp), %r13
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5393e
leaq 0x8(%rsp), %rbp
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbp, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x5393e
movsd (%r13), %xmm0
movsd (%rbp), %xmm1
movsd 0x569f1(%rip), %xmm2    # 0xe18e8
ucomisd %xmm2, %xmm0
jne 0x8af18
jp 0x8af18
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd 0x569dc(%rip), %xmm1    # 0xe18e8
jne 0x8af9a
jp 0x8af9a
ucomisd %xmm2, %xmm1
setnp %al
sete %cl
andb %al, %cl
ucomisd %xmm2, %xmm0
setp %al
setne %dl
orb %al, %dl
movl $0x1, %eax
testb %cl, %dl
jne 0x8af9a
cmpeqsd %xmm0, %xmm2
movq %xmm2, %rax
andl $0x1, %eax
jmp 0x8af58
movsd 0x56998(%rip), %xmm1    # 0xe18e8
movb $0x1, %cl
movapd %xmm1, %xmm0
movb $0x1, %al
andb %al, %cl
cmpb $0x1, %cl
jne 0x8af71
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb890
notl %eax
sarl $0x1f, %eax
jmp 0x8af97
callq 0x7a34f
movl %eax, %ecx
movl $0x0, %eax
testb %cl, %cl
jne 0x8af9a
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x7a42f
movzbl %al, %eax
negl %eax
orl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_delete
void gt_block_delete(GtBlock *block)
{
  GtUword i;
  if (!block) return;
  if (block->reference_count) {
    block->reference_count--;
    return;
  }
  for (i=0;i<gt_array_size(block->elements);i++) {
    GtElement *elem = *(GtElement**) gt_array_get(block->elements, i);
    gt_element_delete(elem);
  }
  if (block->caption)
    gt_str_delete(block->caption);
  gt_array_delete(block->elements);
  if (block->top_level_feature)
    gt_genome_node_delete((GtGenomeNode*) block->top_level_feature);
  gt_free(block);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8b7de
movq %rdi, %rbx
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x8b7e6
decq %rax
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
callq 0x6f310
testq %rax, %rax
je 0x8b819
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6f037
movq (%rax), %rdi
callq 0x8e571
incq %r14
movq (%rbx), %rdi
callq 0x6f310
cmpq %rax, %r14
jb 0x8b7f6
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x8b827
callq 0x3c87b
movq (%rbx), %rdi
callq 0x6f768
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x8b83d
callq 0x4210c
leaq 0x6a4fd(%rip), %rsi     # 0xf5d41
movq %rbx, %rdi
movl $0x1ec, %edx            # imm = 0x1EC
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/canvas_cairo.c
// Function: gt_canvas_cairo_visit_layout_pre
int gt_canvas_cairo_visit_layout_pre(GtCanvas *canvas,
                                     GtLayout *layout,
                                     GtError *err)
{
  double head_track_space = HEAD_TRACK_SPACE_DEFAULT;
  /* get displayed range for internal use */
  canvas->pvt->viewrange = gt_layout_get_range(layout);
  if (gt_canvas_draw_ruler(canvas, canvas->pvt->viewrange, err)) {
    return -1;
  }
  if (gt_style_get_num(canvas->pvt->sty, "format", "ruler_space",
                       &head_track_space, NULL,err) == GT_STYLE_QUERY_ERROR) {
    return -1;
  }
  canvas->pvt->y += HEADER_SPACE + head_track_space;
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movabsq $0x402e000000000000, %rax # imm = 0x402E000000000000
movq %rax, (%rsp)
movq 0x8(%rdi), %r15
movq %rsi, %rdi
callq 0x51ce5
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq 0x8(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x4bd77
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x8b8eb
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rdi
leaq 0x558e2(%rip), %rsi     # 0xe1196
leaq 0x60216(%rip), %rdx     # 0xebad1
movq %rsp, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x5393e
cmpl $0x2, %eax
je 0x8b8eb
movsd (%rsp), %xmm0
addsd 0x60005(%rip), %xmm0    # 0xeb8e0
movq 0x8(%rbx), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/canvas_cairo.c
// Function: gt_canvas_cairo_visit_track_post
int gt_canvas_cairo_visit_track_post(GtCanvas *canvas, GT_UNUSED GtTrack *track,
                                     GtError *err)
{
  double vspace = TRACK_VSPACE_DEFAULT;
  gt_assert(canvas && track);
  /* put track spacer after track */
  if (gt_style_get_num(canvas->pvt->sty, "format", "track_vspace", &vspace,
                       NULL, err) == GT_STYLE_QUERY_ERROR) {
    return -1;
  }
  canvas->pvt->y += vspace;
  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movabsq $0x402e000000000000, %rax # imm = 0x402E000000000000
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0x8bc73
testq %rsi, %rsi
je 0x8bc73
movq %rdx, %r9
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x38(%rax), %rdi
leaq 0x5555f(%rip), %rsi     # 0xe1196
leaq 0x5fe86(%rip), %rdx     # 0xebac4
leaq 0x8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x5393e
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
je 0x8bc6d
movsd 0x8(%rsp), %xmm0
movq 0x8(%rbx), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x2144d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/canvas_cairo.c
// Function: gt_canvas_cairo_visit_line_post
int gt_canvas_cairo_visit_line_post(GtCanvas *canvas, GtLine *line,
                                    GtError *err)
{
  int had_err = 0;
  double lheight,
         bar_vspace = BAR_VSPACE_DEFAULT;
  gt_assert(canvas && line);
  had_err = gt_line_get_height(line, &lheight, canvas->pvt->sty, err);
  if (!had_err) {
    if (gt_style_get_num(canvas->pvt->sty,
                         "format", "bar_vspace",
                         &bar_vspace, NULL, err) == GT_STYLE_QUERY_ERROR) {
      return -1;
    }
    canvas->pvt->y += bar_vspace + lheight/2;
    if (canvas->pvt->bt)
      gt_bittab_delete(canvas->pvt->bt);
    canvas->pvt->bt = NULL;
  }
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movabsq $0x4024000000000000, %rax # imm = 0x4024000000000000
movq %rax, 0x8(%rsp)
testq %rdi, %rdi
je 0x8beed
testq %rsi, %rsi
je 0x8beed
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x38(%rax), %rdx
leaq 0x10(%rsp), %rax
movq %rsi, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x8e6cf
testl %eax, %eax
jne 0x8bee5
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rdi
leaq 0x55312(%rip), %rsi     # 0xe1196
leaq 0x60f60(%rip), %rdx     # 0xecdeb
leaq 0x8(%rsp), %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x5393e
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
je 0x8bee5
movsd 0x10(%rsp), %xmm0
mulsd 0x5e79b(%rip), %xmm0    # 0xea650
addsd 0x8(%rsp), %xmm0
movq 0x8(%rbx), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x8bedb
callq 0x713d5
movq 0x8(%rbx), %rax
movq $0x0, 0x50(%rax)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x214bf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/color.c
// Function: gt_color_new
GtColor* gt_color_new(double red, double green, double blue, double alpha)
{
  GtColor *color = gt_malloc(sizeof *color);
  color->red = red;
  color->green = green;
  color->blue = blue;
  color->alpha = alpha;
  return color;
}

// Assembly:
subq $0x28, %rsp
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
leaq 0x68a74(%rip), %rsi     # 0xf662b
movl $0x20, %edi
movl $0x18, %edx
callq 0x35862
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/color.c
// Function: gt_color_set
void gt_color_set(GtColor *color, double red, double green, double blue,
                  double alpha)
{
  gt_assert(color);
  color->red = red;
  color->green = green;
  color->blue = blue;
  color->alpha = alpha;
}

// Assembly:
testq %rdi, %rdi
je 0x8dc0f
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
movsd %xmm3, 0x18(%rdi)
retq
pushq %rax
callq 0x21615
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/coords.c
// Function: gt_coords_calc_generic_range
GtDrawingRange gt_coords_calc_generic_range(GtRange node_range,
                                            GtRange viewrange)
{
  GtDrawingRange converted_range;
  converted_range.clip = CLIPPED_NONE;
  node_range.end++;
  /* scale coordinates to target image width */
  if (node_range.start < viewrange.start )
    converted_range.clip = CLIPPED_LEFT;
  converted_range.start = gt_coords_convert_point(viewrange, node_range.start);

  if (node_range.end > viewrange.end+1)
    converted_range.clip = (converted_range.clip == CLIPPED_LEFT ?
                                                      CLIPPED_BOTH :
                                                      CLIPPED_RIGHT);
  converted_range.end = gt_coords_convert_point(viewrange, node_range.end);

  return converted_range;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
incq %r15
movq %rsi, %rax
subq %rcx, %rax
movl $0x2, %ecx
sbbl $0x0, %ecx
movl %ecx, 0x10(%rdi)
leaq 0x10(%rsp), %rdi
movq %r14, (%rdi)
movq %r8, 0x8(%rdi)
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x7e19f
movq %rax, %xmm0
punpckldq 0x53757(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5375f(%rip), %xmm0    # 0xe1490
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
leaq 0x1(%r12), %rax
cmpq %rax, %r15
jbe 0x8dd63
xorl %eax, %eax
cmpq %r14, %r13
setb %al
leal (%rax,%rax,2), %eax
movl %eax, 0x10(%rbx)
leaq 0x10(%rsp), %rdi
movq %r14, (%rdi)
movq %r12, 0x8(%rdi)
subq %r14, %r15
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x7e19f
movq %rax, %xmm0
punpckldq 0x536ee(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x536f6(%rip), %xmm0    # 0xe1490
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track.c
// Function: gt_custom_track_create
GtCustomTrack* gt_custom_track_create(const GtCustomTrackClass *ctc)
{
  GtCustomTrack *ct;
  gt_assert(ctc && ctc->size);
  ct = gt_calloc(1, ctc->size);
  ct->c_class = ctc;
  ct->pvt = gt_calloc(1, sizeof (GtCustomTrackMembers));
  return ct;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x8de5f
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x8de5f
leaq 0x68873(%rip), %r14     # 0xf6696
movl $0x1, %edi
movq %r14, %rdx
movl $0x38, %ecx
callq 0x359a6
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x3a, %ecx
callq 0x359a6
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x21683
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/annotationsketch/custom_track.c
// Function: gt_custom_track_delete
void gt_custom_track_delete(GtCustomTrack *ctrack)
{
  if (!ctrack) return;
  if (ctrack->pvt->reference_count) {
    ctrack->pvt->reference_count--;
    return;
  }
  gt_assert(ctrack->c_class);
  if (ctrack->c_class->free)
    ctrack->c_class->free(ctrack);
  gt_free(ctrack->pvt);
  gt_free(ctrack);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8de93
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movl (%rdi), %eax
testl %eax, %eax
je 0x8de9b
decl %eax
movl %eax, (%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x8dee0
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x8deb5
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x687da(%rip), %r14     # 0xf6696
movq %r14, %rsi
movl $0x4f, %edx
callq 0x35c27
movq %rbx, %rdi
movq %r14, %rsi
movl $0x50, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35c27
callq 0x216f1