LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x8a42a
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0x8a42f
movq %rax, %r14
callq 0x3d23c
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x3d318
movq %r12, %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0xa88e1
movq %rax, (%r14)
movq %r12, %rdi
callq 0x3d573
leaq 0x6b345(%rip), %rdx     # 0xf5744
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x20b3e
callq 0x20b07
// File: /workspace/github_c_makefile_star2_O1/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 0x8a500
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x6b78d(%rip), %rsi     # 0xf5bde
movq %rbx, %rdi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x63eb1(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x637f1(%rip), %rsi     # 0xedc72
movq %rbx, %rdi
callq 0x58568
leaq 0x7a(%rip), %rsi        # 0x8a50a
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0xc5862(%rip), %rdx     # 0x14fd10
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
leaq 0x76bbb(%rip), %rsi     # 0x101087
leaq 0xc587d(%rip), %rdx     # 0x14fd50
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x8a505
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20bae
callq 0x20b75
// File: /workspace/github_c_makefile_star2_O1/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 0x6b6ab(%rip), %rdx     # 0xf5bde
movl $0x1, %esi
callq 0x5b252
movq (%rax), %rdi
callq 0xa57f9
movl %eax, %esi
movq %rbx, %rdi
callq 0x58377
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x6b676(%rip), %rdx     # 0xf5bde
movl $0x1, %esi
callq 0x5b252
movq %rax, %r14
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b41f
movq %rax, %r15
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5b41f
movq %rax, %r12
testl %r15d, %r15d
jns 0x8a5ae
leaq 0x6b656(%rip), %rdx     # 0xf5bf7
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
testl %r12d, %r12d
jns 0x8a5c7
leaq 0x6b64c(%rip), %rdx     # 0xf5c06
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
movq (%r14), %rdi
callq 0xa57f9
cmpl %r15d, %eax
ja 0x8a5e8
leaq 0x6b63a(%rip), %rdx     # 0xf5c15
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5aeac
movq (%r14), %rdi
callq 0xa57f9
cmpl %r12d, %eax
ja 0x8a609
leaq 0x6b628(%rip), %rdx     # 0xf5c24
movq %rbx, %rdi
movl $0x3, %esi
callq 0x5aeac
movq (%r14), %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0xa5808
movslq %eax, %rsi
movq %rbx, %rdi
callq 0x58377
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/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 0x8a704
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0x8a709
movq %rax, %r14
callq 0x35584
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0xa515d
movq %rax, (%r14)
testq %rax, %rax
je 0x8a6ee
movq %r12, %rdi
callq 0x35705
cmpq $0x0, (%r14)
je 0x8a70e
leaq 0x6b51b(%rip), %rdx     # 0xf5bde
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa8706
callq 0x20c55
callq 0x20c1e
callq 0x20be7
// File: /workspace/github_c_makefile_star2_O1/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 0x8a7d4
movq %rdi, %rbx
movl $0x1, %esi
xorl %edx, %edx
callq 0x5b1b3
movq %rax, %r15
leaq 0x6b535(%rip), %rdx     # 0xf5c73
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b252
movq %rax, %r12
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
testq %rax, %rax
je 0x8a7d9
movq %rax, %r14
callq 0x35584
movq %rax, %r13
movq (%r12), %rsi
movq %r15, %rdi
movq %rax, %rdx
callq 0xa5795
movq %rax, (%r14)
testq %rax, %rax
je 0x8a7c0
movq %r13, %rdi
callq 0x35705
cmpq $0x0, (%r14)
je 0x8a7de
leaq 0x6b447(%rip), %rdx     # 0xf5bde
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
popq %rbx
popq %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 0xa8706
callq 0x20cfa
callq 0x20cc3
callq 0x20c8c
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x8a8b0
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x6b4c5(%rip), %rsi     # 0xf5cc6
movq %rbx, %rdi
callq 0x5b1df
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x57c3c
leaq 0x63b01(%rip), %rdx     # 0xee31e
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59137
leaq 0x63441(%rip), %rsi     # 0xedc72
movq %rbx, %rdi
callq 0x58568
leaq 0x7a(%rip), %rsi        # 0x8a8ba
movq %rbx, %rdi
xorl %edx, %edx
callq 0x58930
movq %rbx, %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x58f22
leaq 0xc5522(%rip), %rdx     # 0x14fd80
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
leaq 0x7680b(%rip), %rsi     # 0x101087
leaq 0xc552d(%rip), %rdx     # 0x14fdb0
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x8a8b5
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20d68
callq 0x20d31
// File: /workspace/github_c_makefile_star2_O1/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 0x6b3dc(%rip), %rdx     # 0xf5cc6
movl $0x1, %esi
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
callq 0x578c5
cmpl $0x2, %eax
jl 0x8a91d
leaq 0x6acc7(%rip), %rdx     # 0xf55d2
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5b252
movq %rax, %r12
jmp 0x8a920
xorl %r12d, %r12d
callq 0x35584
movq %rax, %r14
movq (%r15), %rdi
testq %r12, %r12
je 0x8a936
movq (%r12), %r8
jmp 0x8a939
xorl %r8d, %r8d
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r14, %r9
callq 0xaa5a8
testl %eax, %eax
je 0x8a961
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa8706
movq %r14, %rdi
callq 0x35705
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/gtlua/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 0x6b34f(%rip), %r14     # 0xf5cf8
movl $0x1, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r15
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0x5b252
movq %rax, %r14
movl $0x8, %esi
movq %rbx, %rdi
callq 0x59e95
movq %rax, %r12
movq (%r15), %rdi
movq (%r14), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xaa1b8
movq %rax, (%r12)
leaq 0x6b2ca(%rip), %rdx     # 0xf5cc6
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x58b98
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x59337
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x8aa75
movq %rdi, %rbx
callq 0x578c5
movl %eax, %ebp
leaq 0x76646(%rip), %rsi     # 0x101087
leaq 0xc5388(%rip), %rdx     # 0x14fdd0
movq %rbx, %rdi
callq 0x5b590
movq %rbx, %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x578d2
movq %rbx, %rdi
callq 0x578c5
cmpl %ebp, %eax
jne 0x8aa7a
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x20dd6
callq 0x20d9f
// File: /workspace/github_c_makefile_star2_O1/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 0x5b1b3
movq %rax, %r12
movq %rax, %rdi
callq 0xb260
cmpq $0x2, %rax
ja 0x8aac1
leaq 0x6b29c(%rip), %rdx     # 0xf5d50
movq %rbx, %rdi
movl $0x1, %esi
callq 0x5aeac
callq 0x3bfe0
movq %rax, %r14
callq 0x35584
movq %rax, %r15
movq %r12, %rdi
callq 0xb260
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xa4151
testq %rax, %rax
je 0x8ab48
movq %rax, %r12
movq %rbx, 0x10(%rsp)
movq %rax, %rdi
callq 0xa6d7b
movq %rax, %r13
leaq 0xb(%rsp), %rbp
leaq 0xc(%rsp), %rbx
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0xa7101
testl %eax, %eax
jne 0x8ab34
cmpl $0x0, 0xc(%rsp)
jne 0x8ab09
movsbl 0xb(%rsp), %esi
movq %r14, %rdi
callq 0x3c28d
jmp 0x8ab09
cmpl $-0x2, %eax
jne 0x8ab69
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xa8706
jmp 0x8aba3
movq %r14, %rdi
callq 0x3d1eb
movq %rbx, %rdi
movq %r15, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa8706
movq %r15, %rdi
callq 0x35705
movq %r14, %rdi
callq 0x3c40b
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x58568
movq %r14, %rdi
callq 0x3d1eb
movq %r13, %rdi
callq 0xa71e5
movq %r12, %rdi
callq 0xa3f62
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_O1/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 0x8ac4a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x8ac4a
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 0x7df58
testl %eax, %eax
je 0x8abf6
addq $0x28, %rsp
popq %rbx
popq %r14
retq
cmpq %rbx, %r14
je 0x8ac33
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 0x8ac37
callq 0x3c40b
movq %rax, %r14
movq %rbx, %rdi
callq 0x3c40b
movq %r14, %rdi
movq %rax, %rsi
callq 0xb890
jmp 0x8abee
xorl %eax, %eax
jmp 0x8abee
xorl %ecx, %ecx
testq %rbx, %rbx
setne %cl
xorl %eax, %eax
negq %rdi
sbbl %eax, %eax
orl %ecx, %eax
jmp 0x8abee
callq 0x20e0d
// File: /workspace/github_c_makefile_star2_O1/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 0x8ad1c
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x8ad08
leaq 0x6b129(%rip), %r14     # 0xf5dda
xorl %r15d, %r15d
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x8e66a
testq %rax, %rax
je 0x8ad17
movq %rax, %r12
movq %rax, %rdi
callq 0x8e67d
movq %rax, %r13
movq %rdx, %rbp
movq %r12, %rdi
callq 0x8e691
movq %r14, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0xb070
incq %r15
movq (%rbx), %rdi
callq 0x6ecda
cmpq %rax, %r15
jb 0x8acb4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x20eed
callq 0x20f26
// File: /workspace/github_c_makefile_star2_O1/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 0x6b078(%rip), %rdx     # 0xf5da1
movl $0x1, %edi
movl $0x48, %esi
movl $0x8a, %ecx
callq 0x3601f
movq %rax, %rbx
movl $0x8, %edi
callq 0x6e93c
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_O1/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 0x8adc8
movq %rdi, %rbx
callq 0x8ad21
movq %rax, %r14
movq %rbx, %rdi
callq 0x41f83
movq %rax, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rbx, %rdi
callq 0x3fdd2
movl %eax, 0x2c(%r14)
movq %rbx, %rdi
callq 0x40276
movq %rax, 0x30(%r14)
movq %rbx, %rdi
callq 0x40459
testb %al, %al
jne 0x8adbd
movq %rbx, %rdi
callq 0x41ca0
movq %rax, 0x38(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x20f5d
// File: /workspace/github_c_makefile_star2_O1/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 0x8ae1b
movq %rsi, %r14
testq %rsi, %rsi
je 0x8ae1b
movq %rdi, %rbx
cmpq $0x0, 0x38(%rdi)
jne 0x8adf4
movq %r14, %rdi
callq 0x41ca0
movq %rax, 0x38(%rbx)
movq %r14, %rdi
callq 0x8e5a8
movq %rsp, %rsi
movq %rax, (%rsi)
movb $0x0, 0x29(%rbx)
movq (%rbx), %rdi
movl $0x8, %edx
callq 0x6ec0e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x20f96
// File: /workspace/github_c_makefile_star2_O1/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 0x8aede
movq %rsi, %r14
testq %rsi, %rsi
je 0x8aede
movq %rdi, %rbx
callq 0x8aee8
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x8aee8
movq %rax, %r15
movq (%r14), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x8aeb5
movl $0x1, %r12d
xorl %ebp, %ebp
leaq 0x10(%rsp), %r13
movq (%r14), %rdi
movq %rbp, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x8e66a
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x8aed9
movq (%rbx), %rdi
movl $0x8, %edx
movq %r13, %rsi
callq 0x6ec0e
movl %r12d, %ebp
movq (%r14), %rdi
callq 0x6ecda
incl %r12d
cmpq %rbp, %rax
ja 0x8ae75
addq 0x8(%rsp), %r15
movq %rbx, %rdi
callq 0x8aee8
movl %r15d, %ecx
cmpq %rcx, %rax
jne 0x8aee3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x21008
callq 0x20fcf
callq 0x21041
// File: /workspace/github_c_makefile_star2_O1/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 0x8afd3
movq %rdi, %rbx
callq 0x8ad21
movq %rax, %r14
movq (%rbx), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x8af6e
xorl %r15d, %r15d
movq %rsp, %r12
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x8e66a
movq %rax, (%rsp)
testq %rax, %rax
je 0x8afce
movq (%r14), %rdi
movl $0x8, %edx
movq %r12, %rsi
callq 0x6ec0e
incq %r15
movq (%rbx), %rdi
callq 0x6ecda
cmpq %rax, %r15
jb 0x8af2e
movq %r14, %rdi
callq 0x8aee8
movq %rax, %r15
movq %rbx, %rdi
callq 0x8aee8
cmpq %rax, %r15
jne 0x8afd8
movq 0x18(%rbx), %rdi
callq 0x3c561
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 0x41ca0
movq %rax, 0x38(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x210b3
callq 0x21125
callq 0x210ec
// File: /workspace/github_c_makefile_star2_O1/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 0x8b090
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6ecda
cmpq $0x1, %rax
jne 0x8b086
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x6e9fa
movq (%rax), %r14
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x6e9fa
cmpq (%rax), %r14
jne 0x8b095
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x8e67d
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movups 0x8(%rbx), %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
callq 0x7df58
testl %eax, %eax
sete %al
jmp 0x8b088
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
callq 0x21242
callq 0x21209
// File: /workspace/github_c_makefile_star2_O1/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 0x8b365
movq %rsi, %r14
testq %rsi, %rsi
je 0x8b365
movq %rdx, %rbx
testq %rdx, %rdx
je 0x8b365
movq %rdi, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4cc15
xorl %ebp, %ebp
testl %eax, %eax
je 0x8b2f9
cmpl $0x1, %eax
je 0x8b35a
movl %eax, %ebp
jmp 0x8b35a
cmpb $0x0, 0x29(%r15)
jne 0x8b31f
movq %r14, %rdi
callq 0x4cc78
movq (%r15), %rdi
leaq 0x58(%rip), %rsi        # 0x8b36a
movq %rax, %rdx
callq 0x6ed73
movb $0x1, 0x29(%r15)
movq (%r15), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x8b35a
xorl %r12d, %r12d
movq (%r15), %rdi
movq %r12, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8e6be
movl %eax, %ebp
incq %r12
movq (%r15), %rdi
callq 0x6ecda
cmpq %rax, %r12
jb 0x8b32f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x21443
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
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 0x8e691
movq %rax, %rbx
movq %r14, %rdi
callq 0x8e691
movq %rax, %r14
xorl %eax, %eax
cmpq %r14, %rbx
je 0x8b487
testq %r15, %r15
je 0x8b3ee
leaq 0x6aede(%rip), %r12     # 0xf629a
leaq 0x10(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x545d2
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x545d2
movsd 0x10(%rsp), %xmm0
ucomisd 0x564ec(%rip), %xmm0    # 0xe18e8
movsd 0x8(%rsp), %xmm1
jne 0x8b417
jp 0x8b417
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd 0x564d5(%rip), %xmm1    # 0xe18e8
jne 0x8b487
jp 0x8b487
ucomisd 0x564c9(%rip), %xmm0    # 0xe18e8
jne 0x8b423
jnp 0x8b434
movl $0x1, %eax
ucomisd 0x564b8(%rip), %xmm1    # 0xe18e8
jne 0x8b434
jnp 0x8b487
ucomisd 0x564ac(%rip), %xmm0    # 0xe18e8
jne 0x8b45e
jp 0x8b45e
ucomisd 0x564a0(%rip), %xmm1    # 0xe18e8
jne 0x8b45e
jp 0x8b45e
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb890
notl %eax
sarl $0x1f, %eax
jmp 0x8b484
callq 0x79fbb
movl %eax, %ecx
movl $0x0, %eax
testb %cl, %cl
jne 0x8b487
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x7a0a0
movzbl %al, %eax
negl %eax
orl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8bcee
movq %rdi, %rbx
movq 0x40(%rdi), %rax
testq %rax, %rax
je 0x8bcf6
decq %rax
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x8bd29
xorl %r14d, %r14d
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
callq 0x8ea90
incq %r14
movq (%rbx), %rdi
callq 0x6ecda
cmpq %rax, %r14
jb 0x8bd06
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x8bd37
callq 0x3d1eb
movq (%rbx), %rdi
callq 0x6f134
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x8bd4d
callq 0x42ade
leaq 0x6a04d(%rip), %rsi     # 0xf5da1
movq %rbx, %rdi
movl $0x1ec, %edx            # imm = 0x1EC
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/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 0x52960
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 0x4ca0d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x8bdfb
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rdi
leaq 0x553d2(%rip), %rsi     # 0xe1196
leaq 0x5fd56(%rip), %rdx     # 0xebb21
movq %rsp, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x545d2
cmpl $0x2, %eax
je 0x8bdfb
movsd (%rsp), %xmm0
addsd 0x5fb45(%rip), %xmm0    # 0xeb930
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_O1/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 0x8c183
testq %rsi, %rsi
je 0x8c183
movq %rdx, %r9
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x38(%rax), %rdi
leaq 0x5504f(%rip), %rsi     # 0xe1196
leaq 0x5f9c6(%rip), %rdx     # 0xebb14
leaq 0x8(%rsp), %rcx
xorl %r8d, %r8d
callq 0x545d2
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
je 0x8c17d
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 0x214ec
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movabsq $0x4024000000000000, %rax # imm = 0x4024000000000000
movq %rax, (%rsp)
testq %rdi, %rdi
je 0x8c402
testq %rsi, %rsi
je 0x8c402
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x38(%rax), %rdx
leaq 0x8(%rsp), %rax
movq %rsi, %rdi
movq %rax, %rsi
movq %r14, %rcx
callq 0x8ebfa
movl %eax, %ebp
testl %eax, %eax
jne 0x8c3f7
movq 0x8(%rbx), %rax
movq 0x38(%rax), %rdi
leaq 0x54dfb(%rip), %rsi     # 0xe1196
leaq 0x60a91(%rip), %rdx     # 0xece33
movq %rsp, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x545d2
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x2, %ecx
je 0x8c3f9
movsd 0x8(%rsp), %xmm0
mulsd 0x5e2d6(%rip), %xmm0    # 0xea6a0
addsd (%rsp), %xmm0
movq 0x8(%rbx), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movq 0x50(%rax), %rdi
testq %rdi, %rdi
je 0x8c3eb
callq 0x70e34
movq 0x8(%rbx), %rax
movq $0x0, 0x50(%rax)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2155e
// File: /workspace/github_c_makefile_star2_O1/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 0x685cb(%rip), %rsi     # 0xf66a6
movl $0x20, %edi
movl $0x18, %edx
callq 0x35ee2
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_O1/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 0x8e133
movsd %xmm0, (%rdi)
movsd %xmm1, 0x8(%rdi)
movsd %xmm2, 0x10(%rdi)
movsd %xmm3, 0x18(%rdi)
retq
pushq %rax
callq 0x216ed
// File: /workspace/github_c_makefile_star2_O1/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 0x7e05b
movq %rax, %xmm0
punpckldq 0x53233(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5323b(%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 0x8e287
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 0x7e05b
movq %rax, %xmm0
punpckldq 0x531ca(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x531d2(%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_O1/genometools[P]genometools/src/annotationsketch/custom_track.c
// Function: gt_custom_track_class_new
const GtCustomTrackClass* gt_custom_track_class_new(size_t size,
                                          GtCustomTrackRenderFunc render,
                                          GtCustomTrackGetHeightFunc get_height,
                                          GtCustomTrackGetTitleFunc get_title,
                                          GtCustomTrackFreeFunc free)
{
  GtCustomTrackClass *c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->render = render;
  c_class->get_height = get_height;
  c_class->get_title = get_title;
  c_class->free = free;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x28, %edi
callq 0x71ca4
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8e383
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x8e383
leaq 0x683ca(%rip), %r14     # 0xf6711
movl $0x1, %edi
movq %r14, %rdx
movl $0x38, %ecx
callq 0x3601f
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x4, %esi
movq %r14, %rdx
movl $0x3a, %ecx
callq 0x3601f
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2175b
// File: /workspace/github_c_makefile_star2_O1/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 0x8e3b7
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movl (%rax), %ecx
testl %ecx, %ecx
je 0x8e3bf
decl %ecx
movl %ecx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x8e404
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x8e3d5
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x68331(%rip), %r14     # 0xf6711
movq %r14, %rsi
movl $0x4f, %edx
callq 0x362a0
movq %rbx, %rdi
movq %r14, %rsi
movl $0x50, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x362a0
callq 0x217c9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/drawing_range.c
// Function: gt_drawing_range_compare
int gt_drawing_range_compare(GtDrawingRange range_a, GtDrawingRange range_b)
{
  gt_assert(range_a.start <= range_a.end && range_b.start <= range_b.end);

  if (gt_double_equals_double(range_a.start, range_b.start) &&
      gt_double_equals_double(range_a.end, range_b.end))
    return 0; /* range_a == range_b */

  if (gt_double_smaller_double(range_a.start, range_b.start) ||
      (gt_double_equals_double(range_a.start, range_b.start)
       && gt_double_smaller_double(range_a.end, range_b.end)))
    return -1; /* range_a < range_b */

  return 1; /* range_a > range_b */
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd 0x30(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jb 0x8e545
leaq 0x48(%rsp), %rax
movsd (%rax), %xmm1
movsd 0x8(%rax), %xmm2
movsd %xmm2, (%rsp)
ucomisd %xmm1, %xmm2
jb 0x8e545
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
callq 0x79fbb
testb %al, %al
je 0x8e4f5
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x79fbb
xorl %ebx, %ebx
testb %al, %al
jne 0x8e53d
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x7a0a0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testb %al, %al
jne 0x8e53d
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x79fbb
testb %al, %al
je 0x8e538
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x7a0a0
testb %al, %al
jne 0x8e53d
movl $0x1, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
callq 0x21913
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/annotationsketch/element.c
// Function: gt_element_new
GtElement* gt_element_new(GtFeatureNode *node)
{
  GtElement *element;
  gt_assert(node);
  element = gt_element_new_empty();
  gt_element_set_type(element, gt_feature_node_get_type(node));
  gt_element_set_range(element, gt_genome_node_get_range((GtGenomeNode*) node));
  element->strand = gt_feature_node_get_strand(node);
  element->mark = gt_feature_node_is_marked(node);
  element->gn = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) node);
  return element;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8e627
movq %rdi, %rbx
leaq 0x68321(%rip), %rdx     # 0xf68dc
movl $0x1, %edi
movl $0x50, %esi
movl $0x3c, %ecx
callq 0x3601f
movq %rax, %r14
movq %rbx, %rdi
callq 0x40276
movq %r14, %rdi
movq %rax, %rsi
callq 0x8e647
movq %rbx, %rdi
callq 0x41f83
movq %r14, %rdi
movq %rax, %rsi
callq 0x8e656
movq %rbx, %rdi
callq 0x3fdd2
movl %eax, 0x10(%r14)
movq %rbx, %rdi
callq 0x4145b
movb %al, 0x48(%r14)
movq %rbx, %rdi
callq 0x41ca0
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2194a