LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/image_info_lua.c
// Function: gt_lua_open_imageinfo
int gt_lua_open_imageinfo(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, IMAGEINFO_METATABLE);
  lua_pushvalue(L, -1); /* duplicate the metatable */
  lua_setfield(L, -2, "__index");
  /* set its _gc field */
  lua_pushstring(L, "__gc");
  lua_pushcfunction(L, imageinfo_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, imageinfo_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", imageinfo_lib_f);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x95103
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x51755(%rip), %rsi     # 0xe67b3
movq %rbx, %rdi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x42206(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f41
leaq 0x41b44(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xcc(%rip), %rsi        # 0x95169
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0x98797(%rip), %rdx     # 0x12d850
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
leaq 0x551a2(%rip), %rsi     # 0xea277
leaq 0x987b4(%rip), %rdx     # 0x12d890
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x95131
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x98eae(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34f52(%rip), %rsi     # 0xca066
leaq 0x418db(%rip), %rdx     # 0xd69f6
leaq 0x526ae(%rip), %rcx     # 0xe77d0
leaq 0x526bd(%rip), %r8      # 0xe77e6
movl $0x94, %r9d
jmp 0x9515d
movq 0x98e80(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34f24(%rip), %rsi     # 0xca066
leaq 0x48c92(%rip), %rdx     # 0xddddb
leaq 0x52680(%rip), %rcx     # 0xe77d0
leaq 0x5268f(%rip), %r8      # 0xe77e6
movl $0xa4, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/image_info_lua.c
// Function: imageinfo_lua_get_height
static int imageinfo_lua_get_height(lua_State *L)
{
  GtImageInfo **ii;
  GtUword height;
  GtError *err = NULL;
  ii = check_imageinfo(L, 1);
  gt_assert(ii);
  height = gt_image_info_get_height(*ii);
  if (height > DBL_MAX)
  {
    err = gt_error_new();
    gt_error_set(err, "image height exceeds %f!", DBL_MAX);
    return gt_lua_error(L, err);
  }
  else
    lua_pushnumber(L, (double) height);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x51623(%rip), %rdx     # 0xe67b3
pushq $0x1
popq %rsi
callq 0x3ae77
testq %rax, %rax
je 0x951bf
movq (%rax), %rdi
callq 0x30f57
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
callq 0x3825b
xorl %edi, %edi
callq 0xc291
xorl %eax, %eax
popq %rbx
retq
movq 0x98df2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34e96(%rip), %rsi     # 0xca066
leaq 0x4b6a2(%rip), %rdx     # 0xe0879
leaq 0x5262f(%rip), %rcx     # 0xe780d
leaq 0x52601(%rip), %r8      # 0xe77e6
pushq $0x2f
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/image_info_lua.c
// Function: imageinfo_lua_num_of_recmaps
static int imageinfo_lua_num_of_recmaps(lua_State *L)
{
  GtImageInfo **ii;
  GtUword nof_rm;
  GtError *err = NULL;
  ii = check_imageinfo(L, 1);
  gt_assert(ii);
  nof_rm = gt_image_info_num_of_rec_maps(*ii);
  if (nof_rm > DBL_MAX)
  {
    err = gt_error_new();
    gt_error_set(err, "number of recmaps exceeds %f!", DBL_MAX);
    return gt_lua_error(L, err);
  }
  else
    lua_pushnumber(L, (double) nof_rm);
  gt_error_delete(err);
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x515b3(%rip), %rdx     # 0xe67b3
pushq $0x1
popq %rsi
callq 0x3ae77
testq %rax, %rax
je 0x95249
movq (%rax), %rdi
callq 0x30e7e
movq %rax, %xmm1
punpckldq 0x3525e(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x35266(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
xorl %edi, %edi
callq 0xc291
xorl %eax, %eax
popq %rbx
retq
movq 0x98d68(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34e0c(%rip), %rsi     # 0xca066
leaq 0x4b618(%rip), %rdx     # 0xe0879
leaq 0x525be(%rip), %rcx     # 0xe7826
leaq 0x52577(%rip), %r8      # 0xe77e6
pushq $0x43
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/image_info_lua.c
// Function: imageinfo_lua_recmaps_as_table
static int imageinfo_lua_recmaps_as_table(lua_State *L)
{
  GtImageInfo **ii;
  GtUword num, i;
  ii = check_imageinfo(L, 1);
  gt_assert(ii);
  num = gt_image_info_num_of_rec_maps(*ii);
  if (num>0)
  {
    lua_newtable(L);
    for (i=0;i<num;i++)
    {
      lua_pushnumber(L, i+1);
      push_recmap_as_table(L, gt_image_info_get_rec_map(*ii, i));
      lua_rawset(L, -3);
    }
  } else lua_pushnil(L);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5151f(%rip), %rdx     # 0xe67b3
pushq $0x1
popq %rsi
callq 0x3ae77
testq %rax, %rax
je 0x95462
movq %rax, %r14
movq (%rax), %rdi
callq 0x30e7e
testq %rax, %rax
je 0x95412
movq %rax, %r15
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38be5
pushq $-0x3
popq %rbp
subq $0x1, %r15
jb 0x9541a
leaq 0x1(%r13), %r12
movq %r12, %xmm1
punpckldq 0x35197(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x3519f(%rip), %xmm1    # 0xca490
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %rbx, %rdi
callq 0x3825b
movq (%r14), %rdi
movq %r13, %rsi
callq 0x30f97
testq %rax, %rax
je 0x9542c
movq %rax, %r13
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x38be5
movq %rbx, %rdi
leaq 0x52545(%rip), %rsi     # 0xe7877
callq 0x38431
movq %r13, %rdi
callq 0x325d5
movq %rbx, %rdi
callq 0x3825b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x38f9d
movq %rbx, %rdi
leaq 0x52521(%rip), %rsi     # 0xe787c
callq 0x38431
movq %r13, %rdi
callq 0x32616
movq %rbx, %rdi
callq 0x3825b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x38f9d
movq %rbx, %rdi
leaq 0x524fd(%rip), %rsi     # 0xe7881
callq 0x38431
movq %r13, %rdi
callq 0x32658
movq %rbx, %rdi
callq 0x3825b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x38f9d
movq %rbx, %rdi
leaq 0x524d9(%rip), %rsi     # 0xe7886
callq 0x38431
movq %r13, %rdi
callq 0x3269a
movq %rbx, %rdi
callq 0x3825b
movq %rbx, %rdi
movl %ebp, %esi
callq 0x38f9d
movq %rbx, %rdi
leaq 0x524b5(%rip), %rsi     # 0xe788b
callq 0x38431
movq %r13, %rdi
callq 0x326dc
movq %rax, %rdi
callq 0x1bec8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x67934
movq %rbx, %rdi
movl %ebp, %esi
callq 0x38f9d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x38f9d
movq %r12, %r13
jmp 0x952ce
movq %rbx, %rdi
callq 0x3824a
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x98b85(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34c29(%rip), %rsi     # 0xca066
leaq 0x49870(%rip), %rdx     # 0xdecb4
leaq 0x52417(%rip), %rcx     # 0xe7862
leaq 0x52394(%rip), %r8      # 0xe77e6
pushq $0x53
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x98b4f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34bf3(%rip), %rsi     # 0xca066
leaq 0x4b3ff(%rip), %rdx     # 0xe0879
leaq 0x523c2(%rip), %rcx     # 0xe7843
leaq 0x5235e(%rip), %r8      # 0xe77e6
pushq $0x6c
jmp 0x95454
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/image_info_lua.c
// Function: imageinfo_lua_new
static int imageinfo_lua_new(lua_State *L)
{
  GtImageInfo **ii;
  ii = lua_newuserdata(L, sizeof (GtImageInfo*));
  gt_assert(ii);
  *ii = gt_image_info_new();
  luaL_getmetatable(L, IMAGEINFO_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x39c01
testq %rax, %rax
je 0x954d5
movq %rax, %r14
callq 0x30d6c
movq %rax, (%r14)
leaq 0x51301(%rip), %rdx     # 0xe67b3
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x98adc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34b80(%rip), %rsi     # 0xca066
leaq 0x4b38c(%rip), %rdx     # 0xe0879
leaq 0x523b1(%rip), %rcx     # 0xe78a5
leaq 0x522eb(%rip), %r8      # 0xe77e6
pushq $0x22
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/layout_lua.c
// Function: gt_lua_open_layout
int gt_lua_open_layout(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, LAYOUT_METATABLE);
  lua_pushvalue(L, -1); /* duplicate the metatable */
  lua_setfield(L, -2, "__index");
  /* set its _gc field */
  lua_pushstring(L, "__gc");
  lua_pushcfunction(L, layout_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, layout_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", layout_lib_f);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x955cf
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq 0x523b7(%rip), %rsi     # 0xe78e1
movq %rbx, %rdi
callq 0x3ae16
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b39
leaq 0x41d3a(%rip), %rdx     # 0xd727e
pushq $-0x2
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x38f41
leaq 0x41678(%rip), %rsi     # 0xd6bd2
movq %rbx, %rdi
callq 0x38431
leaq 0xc6(%rip), %rsi        # 0x9562f
movq %rbx, %rdi
xorl %edx, %edx
callq 0x38814
pushq $-0x3
popq %rsi
movq %rbx, %rdi
callq 0x38d5e
leaq 0x9832b(%rip), %rdx     # 0x12d8b0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
leaq 0x54cd6(%rip), %rsi     # 0xea277
leaq 0x98338(%rip), %rdx     # 0x12d8e0
movq %rbx, %rdi
callq 0x3b11b
movq %rbx, %rdi
movl %r14d, %esi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x955f9
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x989e2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34a86(%rip), %rsi     # 0xca066
leaq 0x4140f(%rip), %rdx     # 0xd69f6
leaq 0x522c9(%rip), %rcx     # 0xe78b7
leaq 0x522d5(%rip), %r8      # 0xe78ca
pushq $0x6d
jmp 0x95621
movq 0x989b8(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34a5c(%rip), %rsi     # 0xca066
leaq 0x487ca(%rip), %rdx     # 0xddddb
leaq 0x5229f(%rip), %rcx     # 0xe78b7
leaq 0x522ab(%rip), %r8      # 0xe78ca
pushq $0x7d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/layout_lua.c
// Function: layout_lua_sketch
static int layout_lua_sketch(lua_State *L)
{
  GtLayout **layout;
  GtCanvas **canvas;
  GtError *err;
  int had_err = 0;
  layout = check_layout(L, 1);
  canvas = check_canvas(L, 2);
  err = gt_error_new();
  had_err = gt_layout_sketch(*layout, *canvas, err);
  if (had_err < 0)
    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 0x52284(%rip), %rdx     # 0xe78e1
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r15
leaq 0x51087(%rip), %rdx     # 0xe66f6
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3ae77
movq %rax, %r12
callq 0xbff0
movq %rax, %r14
movq (%r15), %rdi
movq (%r12), %rsi
movq %rax, %rdx
callq 0x315c9
testl %eax, %eax
js 0x956ae
movq %r14, %rdi
callq 0xc291
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x88ba4
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/layout_lua.c
// Function: layout_lua_get_height
static int layout_lua_get_height(lua_State *L)
{
  GtLayout **layout;
  GtError *err;
  int had_err = 0;
  GtUword height;
  layout = check_layout(L, 1);
  err = gt_error_new();
  had_err = gt_layout_get_height(*layout, &height, err);
  lua_pushnumber(L, height);
  if (had_err < 0)
    return gt_lua_error(L, err);
  gt_error_delete(err);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x52207(%rip), %rdx     # 0xe78e1
pushq $0x1
popq %rbx
movl %ebx, %esi
callq 0x3ae77
movq %rax, %r12
callq 0xbff0
movq %rax, %r15
movq (%r12), %rdi
leaq 0x8(%rsp), %r12
movq %r12, %rsi
movq %rax, %rdx
callq 0x31a49
movsd (%r12), %xmm1
unpcklps 0x34d70(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x34d78(%rip), %xmm1    # 0xca490
movl %eax, %ebp
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq %r14, %rdi
callq 0x3825b
testl %ebp, %ebp
js 0x9573c
movq %r15, %rdi
callq 0xc291
jmp 0x95749
movq %r14, %rdi
movq %r15, %rsi
callq 0x88ba4
movl %eax, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/gtlua/layout_lua.c
// Function: layout_lua_new
static int layout_lua_new(lua_State *L)
{
  GtLayout **layout;
  GtDiagram **diagram;
  unsigned int width;
  GtStyle *style;
  GtError *err;
  diagram = check_diagram(L, 1);
  width = luaL_checkint(L, 2);
  /* create layout */
  style = gt_lua_get_style_from_registry(L);
  layout = lua_newuserdata(L, sizeof (GtLayout*));
  gt_assert(layout);
  err = gt_error_new();
  *layout = gt_layout_new(*diagram, width, style, err);
  if (gt_error_is_set(err))
    return gt_lua_error(L, err);
  gt_error_delete(err);
  luaL_getmetatable(L, LAYOUT_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x51146(%rip), %rdx     # 0xe68b3
pushq $0x1
popq %rsi
callq 0x3ae77
movq %rax, %r14
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x3b001
movq %rax, %r15
movq %rbx, %rdi
callq 0x9590b
movq %rax, %r12
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x39c01
testq %rax, %rax
je 0x9581f
movq %rax, %rbp
callq 0xbff0
movq %rax, %r13
movq (%r14), %rdi
movl %r15d, %esi
movq %r12, %rdx
movq %rax, %rcx
callq 0x311f4
movq %rax, (%rbp)
movq %r13, %rdi
callq 0xc103
testb %al, %al
je 0x957e6
movq %rbx, %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x88ba4
movq %r13, %rdi
callq 0xc291
leaq 0x520ec(%rip), %rdx     # 0xe78e1
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38a63
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x3914f
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x98792(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34836(%rip), %rsi     # 0xca066
leaq 0x3dc9c(%rip), %rdx     # 0xd34d3
leaq 0x520b6(%rip), %rcx     # 0xe78f4
leaq 0x52085(%rip), %r8      # 0xe78ca
pushq $0x2a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/luastyle.c
// Function: gt_lua_put_style_in_registry
void gt_lua_put_style_in_registry(lua_State *L, GtStyle *style)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L && style);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  lua_pushlightuserdata(L, STYLE_KEY);
  lua_pushlightuserdata(L, style);
  lua_rawset(L, LUA_REGISTRYINDEX);
  gt_assert(lua_gettop(L) == stack_size); /* make sure the stack doesn't grow */
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x958ab
movq %rsi, %r14
testq %rsi, %rsi
je 0x958ab
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq -0x6303a(%rip), %rsi    # 0x32840
movq %rbx, %rdi
callq 0x38914
movq %rbx, %rdi
movq %r14, %rsi
callq 0x38914
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38f9d
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x958d5
popq %rbx
popq %r14
popq %rbp
retq
movq 0x98706(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x347aa(%rip), %rsi     # 0xca066
leaq 0x52040(%rip), %rdx     # 0xe7903
leaq 0x52044(%rip), %rcx     # 0xe790e
leaq 0x5205a(%rip), %r8      # 0xe792b
pushq $0x1d
jmp 0x958fd
movq 0x986dc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x34780(%rip), %rsi     # 0xca066
leaq 0x484ee(%rip), %rdx     # 0xddddb
leaq 0x5201a(%rip), %rcx     # 0xe790e
leaq 0x52030(%rip), %r8      # 0xe792b
pushq $0x24
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/annotationsketch/luastyle.c
// Function: gt_lua_get_style_from_registry
GtStyle* gt_lua_get_style_from_registry(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  GtStyle *style;
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  lua_pushlightuserdata(L, STYLE_KEY);
  lua_rawget(L, LUA_REGISTRYINDEX);
  gt_assert(lua_islightuserdata(L, -1));
  style = lua_touserdata(L, -1);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size); /* make sure the stack doesn't grow */
  return style;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x95977
movq %rdi, %rbx
callq 0x377ed
movl %eax, %ebp
leaq -0x630e5(%rip), %rsi    # 0x32840
movq %rbx, %rdi
callq 0x38914
movq %rbx, %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x38abb
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x37b59
cmpl $0x2, %eax
jne 0x959a1
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq 0x381c6
movq %rax, %r14
pushq $-0x2
popq %rsi
movq %rbx, %rdi
callq 0x377fa
movq %rbx, %rdi
callq 0x377ed
cmpl %ebp, %eax
jne 0x959cb
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x9863a(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x346de(%rip), %rsi     # 0xca066
leaq 0x41067(%rip), %rdx     # 0xd69f6
leaq 0x51fb5(%rip), %rcx     # 0xe794b
leaq 0x51f8e(%rip), %r8      # 0xe792b
pushq $0x2d
jmp 0x959f3
movq 0x98610(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x346b4(%rip), %rsi     # 0xca066
leaq 0x51fb1(%rip), %rdx     # 0xe796a
leaq 0x51f8b(%rip), %rcx     # 0xe794b
leaq 0x51f64(%rip), %r8      # 0xe792b
pushq $0x33
jmp 0x959f3
movq 0x985e6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x3468a(%rip), %rsi     # 0xca066
leaq 0x483f8(%rip), %rdx     # 0xddddb
leaq 0x51f61(%rip), %rcx     # 0xe794b
leaq 0x51f3a(%rip), %r8      # 0xe792b
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-ast.c
// Function: tre_ast_new_node
tre_ast_node_t *
tre_ast_new_node(tre_mem_t mem, tre_ast_type_t type, size_t size)
{
  tre_ast_node_t *node;

  node = tre_mem_calloc(mem, sizeof(*node));
  if (!node)
    return NULL;
  node->obj = tre_mem_calloc(mem, size);
  if (!node->obj)
    return NULL;
  node->type = type;
  node->nullable = -1;
  node->submatch_id = -1;

  return node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r13
xorl %r14d, %r14d
pushq $0x1
popq %rcx
pushq $0x30
popq %r8
xorl %esi, %esi
xorl %edx, %edx
callq 0x75ecf
testq %rax, %rax
je 0x95a5c
movq %rax, %r12
xorl %r14d, %r14d
pushq $0x1
popq %rcx
movq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %r8
callq 0x75ecf
movq %rax, 0x8(%r12)
testq %rax, %rax
je 0x95a5c
movl %ebx, (%r12)
orq $-0x1, 0x10(%r12)
movq %r12, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-ast.c
// Function: tre_ast_new_literal
tre_ast_node_t *
tre_ast_new_literal(tre_mem_t mem, int code_min, int code_max, int position)
{
  tre_ast_node_t *node;
  tre_literal_t *lit;

  node = tre_ast_new_node(mem, LITERAL, sizeof(tre_literal_t));
  if (!node)
    return NULL;
  lit = node->obj;
  lit->code_min = code_min;
  lit->code_max = code_max;
  lit->position = position;

  return node;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
pushq $0x28
popq %rdx
xorl %esi, %esi
callq 0x95a04
testq %rax, %rax
je 0x95a97
movq 0x8(%rax), %rcx
movslq %r14d, %rdx
movq %rdx, (%rcx)
movslq %ebp, %rdx
movq %rdx, 0x8(%rcx)
movl %ebx, 0x10(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-ast.c
// Function: tre_ast_new_iter
tre_ast_node_t *
tre_ast_new_iter(tre_mem_t mem, tre_ast_node_t *arg, int min, int max,
		 int minimal)
{
  tre_ast_node_t *node;
  tre_iteration_t *iter;

  node = tre_ast_new_node(mem, ITERATION, sizeof(tre_iteration_t));
  if (!node)
    return NULL;
  iter = node->obj;
  iter->arg = arg;
  iter->min = min;
  iter->max = max;
  iter->minimal = minimal;
  node->num_submatches = arg->num_submatches;

  return node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
pushq $0x2
popq %rsi
pushq $0x20
popq %rdx
callq 0x95a04
testq %rax, %rax
je 0x95ae1
movq 0x8(%rax), %rcx
movq %r14, (%rcx)
movl %r15d, 0x8(%rcx)
movl %ebp, 0xc(%rcx)
movb 0x10(%rcx), %dl
andb $0x1, %bl
andb $-0x2, %dl
orb %bl, %dl
movb %dl, 0x10(%rcx)
movl 0x18(%r14), %ecx
movl %ecx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-ast.c
// Function: tre_ast_new_union
tre_ast_node_t *
tre_ast_new_union(tre_mem_t mem, tre_ast_node_t *left, tre_ast_node_t *right)
{
  tre_ast_node_t *node;

  node = tre_ast_new_node(mem, UNION, sizeof(tre_union_t));
  if (node == NULL)
    return NULL;
  ((tre_union_t *)node->obj)->left = left;
  ((tre_union_t *)node->obj)->right = right;
  node->num_submatches = left->num_submatches + right->num_submatches;

  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
pushq $0x3
popq %rsi
pushq $0x10
popq %rdx
callq 0x95a04
testq %rax, %rax
je 0x95b1b
movq 0x8(%rax), %rcx
movq %rbx, (%rcx)
movq %r14, 0x8(%rcx)
movl 0x18(%r14), %ecx
addl 0x18(%rbx), %ecx
movl %ecx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/tre/lib/tre-ast.c
// Function: tre_ast_new_catenation
tre_ast_node_t *
tre_ast_new_catenation(tre_mem_t mem, tre_ast_node_t *left,
		       tre_ast_node_t *right)
{
  tre_ast_node_t *node;

  node = tre_ast_new_node(mem, CATENATION, sizeof(tre_catenation_t));
  if (node == NULL)
    return NULL;
  ((tre_catenation_t *)node->obj)->left = left;
  ((tre_catenation_t *)node->obj)->right = right;
  node->num_submatches = left->num_submatches + right->num_submatches;

  return node;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq 0x95a04
testq %rax, %rax
je 0x95b52
movq 0x8(%rax), %rcx
movq %rbx, (%rcx)
movq %r14, 0x8(%rcx)
movl 0x18(%r14), %ecx
addl 0x18(%rbx), %ecx
movl %ecx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/bzip2-1.0.6/compress.c
// Function: bsPutUInt32
static
void bsPutUInt32 ( EState* s, UInt32 u )
{
   bsW ( s, 8, (u >> 24) & 0xffL );
   bsW ( s, 8, (u >> 16) & 0xffL );
   bsW ( s, 8, (u >>  8) & 0xffL );
   bsW ( s, 8,  u        & 0xffL );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edx
shrl $0x18, %edx
pushq $0x8
popq %rbp
movl %ebp, %esi
callq 0x974c4
movl %ebx, %edx
shrl $0x10, %edx
movl $0xff, %r15d
andl %r15d, %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x974c4
movl %ebx, %edx
shrl $0x8, %edx
andl %r15d, %edx
movq %r14, %rdi
movl %ebp, %esi
callq 0x974c4
andl %r15d, %ebx
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x974c4
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/adler32.c
// Function: adler32_combine_
local uLong adler32_combine_(uLong adler1, uLong adler2, z_off64_t len2) {
    unsigned long sum1;
    unsigned long sum2;
    unsigned rem;

    /* for negative len, return invalid adler32 as a clue for debugging */
    if (len2 < 0)
        return 0xffffffffUL;

    /* the derivation of this formula is left as an exercise for the reader */
    MOD63(len2);                /* assumes len2 >= 0 */
    rem = (unsigned)len2;
    sum1 = adler1 & 0xffff;
    sum2 = rem * sum1;
    MOD(sum2);
    sum1 += (adler2 & 0xffff) + BASE - 1;
    sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum2 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
    if (sum2 >= BASE) sum2 -= BASE;
    return sum1 | (sum2 << 16);
}

// Assembly:
testq %rdx, %rdx
js 0x9a812
movl $0xfff1, %r8d           # imm = 0xFFF1
movq %rdx, %rax
xorl %edx, %edx
divq %r8
movq %rdx, %rcx
movl $0xffff, %edx           # imm = 0xFFFF
movq %rdi, %rax
andq %rdx, %rax
andq %rsi, %rdx
leaq (%rax,%rdx), %r9
leaq (%rax,%rdx), %r10
decq %r10
imull %ecx, %eax
movl $0xfff1, %r11d          # imm = 0xFFF1
xorl %edx, %edx
divl %r11d
addl $0xfff0, %r9d           # imm = 0xFFF0
shrl $0x10, %edi
shrl $0x10, %esi
addq %rdi, %rsi
subq %rcx, %rsi
addq %rdx, %rsi
leaq (%rsi,%r8), %rax
cmpl %r11d, %r9d
movl $0xfff0, %ecx           # imm = 0xFFF0
cmovaeq %r10, %rcx
movq $-0xfff1, %rdx          # imm = 0xFFFF000F
leaq (%rcx,%rdx), %rdi
cmpq %r8, %rcx
cmovbq %rcx, %rdi
addq %rdx, %rsi
cmpq $0x1ffe2, %rax          # imm = 0x1FFE2
cmovbq %rax, %rsi
movq %rsi, %rcx
shlq $0x10, %rcx
movabsq $-0xfff10000, %rax      # imm = 0xFFFFFFFF000F0000
addq %rcx, %rax
cmpq %r8, %rsi
cmovbq %rcx, %rax
orq %rdi, %rax
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/crc32.c
// Function: crc_word
local z_crc_t crc_word(z_word_t data) {
    int k;
    for (k = 0; k < W; k++)
        data = (data >> 8) ^ crc_table[data & 0xff];
    return (z_crc_t)data;
}

// Assembly:
movq %rdi, %rax
pushq $0x8
popq %rcx
leaq 0x4d057(%rip), %rdx     # 0xe7b90
subl $0x1, %ecx
jb 0x9ab50
movq %rax, %rsi
shrq $0x8, %rsi
movzbl %al, %eax
movl (%rdx,%rax,4), %eax
xorq %rsi, %rax
jmp 0x9ab39
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/crc32.c
// Function: multmodp
local z_crc_t multmodp(z_crc_t a, z_crc_t b) {
    z_crc_t m, p;

    m = (z_crc_t)1 << 31;
    p = 0;
    for (;;) {
        if (a & m) {
            p ^= b;
            if ((a & (m - 1)) == 0)
                break;
        }
        m >>= 1;
        b = b & 1 ? (b >> 1) ^ POLY : b >> 1;
    }
    return p;
}

// Assembly:
xorl %eax, %eax
movl $0x80000000, %ecx       # imm = 0x80000000
testl %edi, %ecx
je 0x9ab97
xorl %esi, %eax
leal -0x1(%rcx), %edx
testl %edi, %edx
je 0x9abb4
shrl %ecx
movl %esi, %edx
shrl %edx
movl %edx, %r8d
xorl $0xedb88320, %r8d       # imm = 0xEDB88320
testb $0x1, %sil
cmovel %edx, %r8d
movl %r8d, %esi
jmp 0x9ab8a
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/crc32.c
// Function: x2nmodp
local z_crc_t x2nmodp(z_off64_t n, unsigned k) {
    z_crc_t p;

    p = (z_crc_t)1 << 31;           /* x^0 == 1 */
    while (n) {
        if (n & 1)
            p = multmodp(x2n_table[k & 31], p);
        n >>= 1;
        k++;
    }
    return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x80000000, %eax       # imm = 0x80000000
pushq $0x3
popq %rbp
leaq 0x4f3c5(%rip), %r14     # 0xe9f90
testq %rbx, %rbx
je 0x9abec
testb $0x1, %bl
je 0x9abe5
movl %ebp, %ecx
andl $0x1f, %ecx
movl (%r14,%rcx,4), %edi
movl %eax, %esi
callq 0x9ab83
sarq %rbx
incl %ebp
jmp 0x9abcb
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_clone
GtAlphabet* gt_alphabet_clone(const GtAlphabet *alphabet)
{
  unsigned int i;
  GtAlphabet *newalpha;
  gt_assert(alphabet);

  newalpha = gt_malloc(sizeof *newalpha);
  newalpha->domainsize = alphabet->domainsize;
  newalpha->mapsize = alphabet->mapsize;
  newalpha->mappedwildcards = alphabet->mappedwildcards;
  newalpha->wildcardshow = alphabet->wildcardshow;
  newalpha->bitspersymbol = alphabet->bitspersymbol;
  newalpha->alphadef = gt_str_ref(alphabet->alphadef);
  newalpha->reference_count = 0;
  newalpha->refmutex = gt_mutex_new();
  for (i=0; i<=(unsigned int) GT_MAXALPHABETCHARACTER; i++)
  {
    newalpha->symbolmap[i] = alphabet->symbolmap[i];
  }
  newalpha->characters = gt_malloc(alphabet->mapsize * sizeof (GtUchar));
  for (i=0; i<newalpha->mapsize; i++)
  {
    newalpha->characters[i] = alphabet->characters[i];
  }
  newalpha->mapdomain = gt_malloc(alphabet->domainsize * sizeof (GtUchar));
  for (i=0; i<newalpha->domainsize; i++)
  {
    newalpha->mapdomain[i] = alphabet->mapdomain[i];
  }
  return newalpha;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9ad22
movq %rdi, %rbx
leaq 0x4f3ef(%rip), %rsi     # 0xea022
movl $0x138, %edi            # imm = 0x138
movl $0x16e, %edx            # imm = 0x16E
callq 0xccb0
movq %rax, %r14
movq (%rbx), %rax
movq %rax, (%r14)
movl 0x8(%rbx), %eax
movl %eax, 0x8(%r14)
movb 0x14(%rbx), %al
movb %al, 0x14(%r14)
movl 0xc(%rbx), %eax
movl %eax, 0xc(%r14)
movq 0x130(%rbx), %rdi
callq 0x146aa
movq %rax, 0x130(%r14)
andl $0x0, 0x10(%r14)
callq 0x15f7b
movq %rax, 0x128(%r14)
pushq $0x15
popq %rax
cmpq $0x115, %rax            # imm = 0x115
je 0x9ac9b
movb (%rbx,%rax), %cl
movb %cl, (%r14,%rax)
incq %rax
jmp 0x9ac87
movl 0x4(%rbx), %edi
leaq 0x4f37d(%rip), %rsi     # 0xea022
movl $0x17b, %edx            # imm = 0x17B
callq 0xccb0
movq %rax, 0x120(%r14)
xorl %eax, %eax
movl 0x4(%r14), %ecx
cmpq %rcx, %rax
jae 0x9acda
movq 0x120(%rbx), %rcx
movb (%rcx,%rax), %cl
movq 0x120(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x9acb8
movl (%rbx), %edi
leaq 0x4f33f(%rip), %rsi     # 0xea022
movl $0x180, %edx            # imm = 0x180
callq 0xccb0
movq %rax, 0x118(%r14)
xorl %eax, %eax
movl (%r14), %ecx
cmpq %rcx, %rax
jae 0x9ad17
movq 0x118(%rbx), %rcx
movb (%rcx,%rax), %cl
movq 0x118(%r14), %rdx
movb %cl, (%rdx,%rax)
incq %rax
jmp 0x9acf6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x9328f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2f333(%rip), %rsi     # 0xca066
leaq 0x48bde(%rip), %rdx     # 0xe3918
leaq 0x4f2cf(%rip), %rcx     # 0xea010
leaq 0x4f2da(%rip), %r8      # 0xea022
movl $0x16c, %r9d            # imm = 0x16C
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_ref
GtAlphabet* gt_alphabet_ref(GtAlphabet *alphabet)
{
  gt_assert(alphabet);
  gt_mutex_lock(alphabet->refmutex);
  alphabet->reference_count++;
  gt_mutex_unlock(alphabet->refmutex);
  return alphabet;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x9ad83
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
callq 0x16028
incl 0x10(%rbx)
movq 0x128(%rbx), %rdi
callq 0x1609f
movq %rbx, %rax
popq %rbx
retq
movq 0x9322e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2f2d2(%rip), %rsi     # 0xca066
leaq 0x48b7d(%rip), %rdx     # 0xe3918
leaq 0x4f294(%rip), %rcx     # 0xea036
leaq 0x4f279(%rip), %r8      # 0xea022
movl $0x18a, %r9d            # imm = 0x18A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_equals
bool gt_alphabet_equals(const GtAlphabet *a, const GtAlphabet *b)
{
  gt_assert(a && b);
  if (a->domainsize != b->domainsize) return false;
  if (a->mapsize != b->mapsize) return false;
  if (a->mappedwildcards != b->mappedwildcards) return false;
  if (a->wildcardshow != b->wildcardshow) return false;
  if (memcmp(a->symbolmap, b->symbolmap,
             GT_MAXALPHABETCHARACTER * sizeof (GtUchar)))
    return false;
  if (memcmp(a->characters, b->characters,
             a->mapsize * sizeof (GtUchar)))
    return false;
  if (memcmp(a->mapdomain, b->mapdomain,
             a->domainsize * sizeof (GtUchar)))
    return false;
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9ae5a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x9ae5a
movq %rdi, %r14
movl (%rdi), %r15d
cmpl (%rbx), %r15d
jne 0x9ae2f
movl 0x4(%r14), %r12d
cmpl 0x4(%rbx), %r12d
jne 0x9ae2f
movl 0x8(%r14), %eax
cmpl 0x8(%rbx), %eax
jne 0x9ae2f
movb 0x14(%r14), %al
cmpb 0x14(%rbx), %al
jne 0x9ae2f
leaq 0x15(%r14), %rdi
leaq 0x15(%rbx), %rsi
movl $0xff, %edx
callq 0xb6b0
testl %eax, %eax
jne 0x9ae2f
movq 0x120(%r14), %rdi
movq 0x120(%rbx), %rsi
movq %r12, %rdx
callq 0xb6b0
testl %eax, %eax
je 0x9ae3d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x118(%r14), %rdi
movq 0x118(%rbx), %rsi
movq %r15, %rdx
callq 0xb6b0
testl %eax, %eax
sete %al
jmp 0x9ae31
movq 0x93157(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2f1fb(%rip), %rsi     # 0xca066
leaq 0x3f215(%rip), %rdx     # 0xda087
leaq 0x4f1cd(%rip), %rcx     # 0xea046
leaq 0x4f1a2(%rip), %r8      # 0xea022
movl $0x193, %r9d            # imm = 0x193
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_add_mapping
void gt_alphabet_add_mapping(GtAlphabet *alphabet, const char *characters)
{
  size_t i, num_of_characters;
  gt_assert(alphabet && characters);
  num_of_characters = strlen(characters);
  gt_assert(num_of_characters);
  alphabet->mapdomain = gt_realloc(alphabet->mapdomain,
                                   (size_t) alphabet->domainsize
                                      + num_of_characters);
  memcpy(alphabet->mapdomain + alphabet->domainsize, characters,
         num_of_characters);
  alphabet->domainsize += num_of_characters;
  alphabet->symbolmap[(int) characters[0]] = (GtUchar) alphabet->mapsize;
  alphabet->characters = gt_realloc(alphabet->characters,
                                    (size_t) alphabet->domainsize);
  alphabet->characters[alphabet->mapsize] = (GtUchar) characters[0];
  for (i = 0; i < num_of_characters; i++)
    alphabet->symbolmap[(int) characters[i]] = (GtUchar) alphabet->mapsize;
  alphabet->mapsize++;
  alphabet->bitspersymbol
    = gt_determinebitspervalue((GtUword) alphabet->mapsize);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9af63
movq %rsi, %r14
testq %rsi, %rsi
je 0x9af63
movq %rdi, %rbx
movq %r14, %rdi
callq 0xb260
testq %rax, %rax
je 0x9af91
movq %rax, %r15
movq 0x118(%rbx), %rdi
movl (%rbx), %esi
addq %rax, %rsi
leaq 0x4f149(%rip), %r12     # 0xea022
movq %r12, %rdx
movl $0x1ac, %ecx            # imm = 0x1AC
callq 0xcfc2
movq %rax, 0x118(%rbx)
movl (%rbx), %edi
addq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb520
addl %r15d, (%rbx)
movb 0x4(%rbx), %al
movsbq (%r14), %rcx
movb %al, 0x15(%rbx,%rcx)
movq 0x120(%rbx), %rdi
movl (%rbx), %esi
movq %r12, %rdx
movl $0x1b2, %ecx            # imm = 0x1B2
callq 0xcfc2
movq %rax, 0x120(%rbx)
movb (%r14), %cl
movl 0x4(%rbx), %edx
movb %cl, (%rax,%rdx)
xorl %eax, %eax
movl 0x4(%rbx), %edi
cmpq %rax, %r15
je 0x9af4a
movsbq (%r14,%rax), %rcx
movb %dil, 0x15(%rbx,%rcx)
incq %rax
jmp 0x9af33
incl %edi
movl %edi, 0x4(%rbx)
callq 0x58fe7
movl %eax, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x9304e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2f0f2(%rip), %rsi     # 0xca066
leaq 0x4f0de(%rip), %rdx     # 0xea059
leaq 0x4f0ee(%rip), %rcx     # 0xea070
leaq 0x4f099(%rip), %r8      # 0xea022
movl $0x1a7, %r9d            # imm = 0x1A7
jmp 0x9afbd
movq 0x93020(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2f0c4(%rip), %rsi     # 0xca066
leaq 0x4f0df(%rip), %rdx     # 0xea088
leaq 0x4f0c0(%rip), %rcx     # 0xea070
leaq 0x4f06b(%rip), %r8      # 0xea022
movl $0x1a9, %r9d            # imm = 0x1A9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_add_wildcard
void gt_alphabet_add_wildcard(GtAlphabet *alphabet, char wildcard)
{
  gt_assert(alphabet);
  alphabet->mapdomain = gt_realloc(alphabet->mapdomain,
                                   (size_t) alphabet->domainsize + 1);
  alphabet->mapdomain[alphabet->domainsize] = (GtUchar) wildcard;
  alphabet->domainsize++;
  alphabet->symbolmap[(int) wildcard] = (GtUchar) GT_WILDCARD;
  if (alphabet->wildcardshow == (GtUchar) GT_UNDEFCHAR) {
    alphabet->wildcardshow = (GtUchar) wildcard;
    alphabet->mapsize++;
  }
  alphabet->mappedwildcards++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9b022
movl %esi, %ebp
movq %rdi, %rbx
movq 0x118(%rdi), %rdi
movl (%rbx), %esi
incq %rsi
leaq 0x4f039(%rip), %rdx     # 0xea022
movl $0x1bf, %ecx            # imm = 0x1BF
callq 0xcfc2
movq %rax, 0x118(%rbx)
movl (%rbx), %ecx
movb %bpl, (%rax,%rcx)
incl (%rbx)
movsbq %bpl, %rax
movb $-0x2, 0x15(%rbx,%rax)
cmpb $-0x3, 0x14(%rbx)
jne 0x9b018
movb %bpl, 0x14(%rbx)
incl 0x4(%rbx)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x92f8f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2f033(%rip), %rsi     # 0xca066
leaq 0x488de(%rip), %rdx     # 0xe3918
leaq 0x4f059(%rip), %rcx     # 0xea09a
leaq 0x4efda(%rip), %r8      # 0xea022
movl $0x1bd, %r9d            # imm = 0x1BD
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_from_sequence
GtAlphabet* gt_alphabet_new_from_sequence(const GtStrArray *filenametab,
                                          GtError *err)
{
  GtAlphabet *alpha;
  int had_err = 0;
  gt_error_check(err);

  alpha = gt_alphabet_new_empty();
  if (assign_protein_or_dna_alphabet(alpha,filenametab,err) != 0) {
    had_err = -1;
    gt_assert(gt_error_is_set(err));
  }
  if (had_err)
  {
    gt_alphabet_delete(alpha);
    return NULL;
  }
  return alpha;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rsi, %rsi
je 0x9b076
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x9b0d3
callq 0x9b167
movq %rax, %rbx
testq %r14, %r14
je 0x9b08f
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x9b101
movq %r15, %rdi
movq %r14, %rsi
callq 0x55127
testl %eax, %eax
js 0x9b0ad
movq %rbx, %rdi
cmpl $0x1, %eax
jne 0x9b0c5
callq 0x9b3bc
jmp 0x9b0ca
movq %r14, %rdi
callq 0xc103
testb %al, %al
je 0x9b12f
movq %rbx, %rdi
callq 0x9b1c1
xorl %ebx, %ebx
jmp 0x9b0ca
callq 0x9b2c6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x92ede(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ef82(%rip), %rsi     # 0xca066
leaq 0x2f56e(%rip), %rdx     # 0xca659
leaq 0x4efc1(%rip), %rcx     # 0xea0b3
leaq 0x4ef29(%rip), %r8      # 0xea022
movl $0x246, %r9d            # imm = 0x246
jmp 0x9b15b
movq 0x92eb0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ef54(%rip), %rsi     # 0xca066
leaq 0x2f540(%rip), %rdx     # 0xca659
leaq 0x4f399(%rip), %rcx     # 0xea4b9
leaq 0x4eefb(%rip), %r8      # 0xea022
movl $0x231, %r9d            # imm = 0x231
jmp 0x9b15b
movq 0x92e82(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ef26(%rip), %rsi     # 0xca066
leaq 0x55bf2(%rip), %rdx     # 0xf0d39
leaq 0x4ef65(%rip), %rcx     # 0xea0b3
leaq 0x4eecd(%rip), %r8      # 0xea022
movl $0x24b, %r9d            # imm = 0x24B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_empty
GtAlphabet* gt_alphabet_new_empty(void)
{
  GtAlphabet *a = gt_malloc(sizeof *a);
  a->domainsize = 0;
  a->mapsize = 0;
  a->mappedwildcards = 0;
  a->bitspersymbol = 0;
  a->reference_count = 0;
  a->refmutex = gt_mutex_new();
  a->wildcardshow = (GtUchar) GT_UNDEFCHAR;
  memset(a->symbolmap, (int) GT_UNDEFCHAR, (size_t) GT_MAXALPHABETCHARACTER+1);
  a->mapdomain = NULL;
  a->characters = NULL;
  a->alphadef = NULL;
  return a;
}

// Assembly:
pushq %rbx
leaq 0x4eeb3(%rip), %rsi     # 0xea022
movl $0x138, %edi            # imm = 0x138
movl $0x269, %edx            # imm = 0x269
callq 0xccb0
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andl $0x0, 0x10(%rax)
callq 0x15f7b
movq %rax, 0x128(%rbx)
leaq 0x14(%rbx), %rdi
movl $0x101, %edx            # imm = 0x101
movl $0xfd, %esi
callq 0xb2f0
andq $0x0, 0x130(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_delete
void gt_alphabet_delete(GtAlphabet *alphabet)
{
  if (!alphabet) return;
  gt_mutex_lock(alphabet->refmutex);
  if (alphabet->reference_count) {
    alphabet->reference_count--;
    gt_mutex_unlock(alphabet->refmutex);
    return;
  }
  gt_mutex_unlock(alphabet->refmutex);
  gt_free(alphabet->mapdomain);
  gt_free(alphabet->characters);
  if (alphabet->alphadef != NULL)
    gt_str_delete(alphabet->alphadef);
  gt_mutex_delete(alphabet->refmutex);
  gt_free(alphabet);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9b1f8
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
callq 0x16028
movl 0x10(%rbx), %eax
testl %eax, %eax
je 0x9b200
decl %eax
movl %eax, 0x10(%rbx)
movq 0x128(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1609f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x128(%rbx), %rdi
callq 0x1609f
movq 0x118(%rbx), %rdi
leaq 0x4ee08(%rip), %r14     # 0xea022
movq %r14, %rsi
movl $0x444, %edx            # imm = 0x444
callq 0xd249
movq 0x120(%rbx), %rdi
movq %r14, %rsi
movl $0x445, %edx            # imm = 0x445
callq 0xd249
movq 0x130(%rbx), %rdi
testq %rdi, %rdi
je 0x9b24c
callq 0x152db
movq 0x128(%rbx), %rdi
callq 0x15fd3
leaq 0x4edc3(%rip), %rsi     # 0xea022
movq %rbx, %rdi
movl $0x449, %edx            # imm = 0x449
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_dna
GtAlphabet* gt_alphabet_new_dna(void)
{
  GtAlphabet *a;
  a = gt_alphabet_new_empty();
  gt_assert(a);
  assign_dna_alphabet(a);
  return a;
}

// Assembly:
pushq %rbx
callq 0x9b167
testq %rax, %rax
je 0x9b28e
movq %rax, %rbx
movq %rax, %rdi
callq 0x9b2c6
movq %rbx, %rax
popq %rbx
retq
movq 0x92d23(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2edc7(%rip), %rsi     # 0xca066
leaq 0x3de7e(%rip), %rdx     # 0xd9124
leaq 0x4ee24(%rip), %rcx     # 0xea0d1
leaq 0x4ed6e(%rip), %r8      # 0xea022
movl $0x259, %r9d            # imm = 0x259
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: assign_dna_alphabet
static void assign_dna_alphabet(GtAlphabet *alpha)
{
  alpha->wildcardshow = (GtUchar) DNAWILDCARDS[0];
  alpha->mappedwildcards = (unsigned int) strlen(DNAWILDCARDS);
  alpha->domainsize = (unsigned int) strlen(DNAALPHABETDOMAIN);
  alpha->bitspersymbol = 3U; /* as we have to represent 4 + 2 characters */
  alpha->mapdomain = gt_malloc(sizeof (GtUchar) * alpha->domainsize);
  memcpy(alpha->mapdomain,(GtUchar *) DNAALPHABETDOMAIN,
         (size_t) alpha->domainsize);
  alpha->mapsize = MAPSIZEDNA;
  alpha->characters = gt_calloc((size_t) UCHAR_MAX+1, sizeof (GtUchar));
  memcpy(alpha->characters,"acgt",(size_t) (MAPSIZEDNA-1));
  alpha->characters[GT_WILDCARD] = (GtUchar) DNAWILDCARDS[0];
  alpha->characters[MAPSIZEDNA-1] = (GtUchar) DNAWILDCARDS[0];
  assign_dna_symbolmap(alpha->symbolmap);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x6e, %bpl
movb %bpl, 0x14(%rdi)
movabsq $0x300000016, %rax      # imm = 0x300000016
movq %rax, 0x8(%rdi)
movl $0x20, (%rdi)
leaq 0x4ed33(%rip), %r14     # 0xea022
pushq $0x20
popq %rdi
movq %r14, %rsi
movl $0x1dd, %edx            # imm = 0x1DD
callq 0xccb0
movq %rax, 0x118(%rbx)
movl (%rbx), %edx
leaq 0x4f1c9(%rip), %rsi     # 0xea4d8
movq %rax, %rdi
callq 0xb520
movl $0x5, 0x4(%rbx)
pushq $0x1
popq %rsi
movl $0x100, %edi            # imm = 0x100
movq %r14, %rdx
movl $0x1e1, %ecx            # imm = 0x1E1
callq 0xce9a
movq %rax, 0x120(%rbx)
movl $0x74676361, (%rax)     # imm = 0x74676361
movq 0x120(%rbx), %rax
movb %bpl, 0xfe(%rax)
movq 0x120(%rbx), %rax
movb %bpl, 0x4(%rax)
addq $0x15, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9bdfd
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: gt_alphabet_new_protein
GtAlphabet* gt_alphabet_new_protein(void)
{
  GtAlphabet *a;
  a = gt_alphabet_new_empty();
  gt_assert(a);
  assign_protein_alphabet(a);
  return a;
}

// Assembly:
pushq %rbx
callq 0x9b167
testq %rax, %rax
je 0x9b384
movq %rax, %rbx
movq %rax, %rdi
callq 0x9b3bc
movq %rbx, %rax
popq %rbx
retq
movq 0x92c2d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2ecd1(%rip), %rsi     # 0xca066
leaq 0x3dd88(%rip), %rdx     # 0xd9124
leaq 0x4ed42(%rip), %rcx     # 0xea0e5
leaq 0x4ec78(%rip), %r8      # 0xea022
movl $0x262, %r9d            # imm = 0x262
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/alphabet.c
// Function: assign_protein_alphabet
static void assign_protein_alphabet(GtAlphabet *alpha)
{
  alpha->wildcardshow = (GtUchar) PROTEINWILDCARDS[0];
  alpha->domainsize = (unsigned int) strlen(PROTEINALPHABETDOMAIN);
  alpha->mappedwildcards = (unsigned int) strlen(PROTEINWILDCARDS);
  alpha->bitspersymbol = 5U; /* as we have to represent 20 + 2 characters */
  alpha->mapdomain = gt_malloc(sizeof (GtUchar) * alpha->domainsize);
  memcpy(alpha->mapdomain,
         (GtUchar *) PROTEINALPHABETDOMAIN,(size_t) alpha->domainsize);
  alpha->mapsize = MAPSIZEPROTEIN;
  alpha->characters = gt_calloc((size_t) UCHAR_MAX+1, sizeof (GtUchar));
  memcpy(alpha->characters,PROTEINUPPERAMINOACIDS,(size_t) (MAPSIZEPROTEIN-1));
  alpha->characters[GT_WILDCARD] = (GtUchar) PROTEINWILDCARDS[0];
  alpha->characters[MAPSIZEPROTEIN-1] = (GtUchar) PROTEINWILDCARDS[0];
  assignproteinsymbolmap(alpha->symbolmap);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x58, %bpl
movb %bpl, 0x14(%rdi)
movl $0x1c, (%rdi)
movabsq $0x500000008, %rax      # imm = 0x500000008
movq %rax, 0x8(%rdi)
leaq 0x4ec3d(%rip), %r14     # 0xea022
pushq $0x1c
popq %rdi
movq %r14, %rsi
movl $0x220, %edx            # imm = 0x220
callq 0xccb0
movq %rax, 0x118(%rbx)
movl (%rbx), %edx
leaq 0x4f0f4(%rip), %rsi     # 0xea4f9
movq %rax, %rdi
callq 0xb520
movl $0x15, 0x4(%rbx)
pushq $0x1
popq %rsi
movl $0x100, %edi            # imm = 0x100
movq %r14, %rdx
movl $0x224, %ecx            # imm = 0x224
callq 0xce9a
movq %rax, 0x120(%rbx)
movups 0x4f0df(%rip), %xmm0    # 0xea516
movups %xmm0, (%rax)
movl $0x434d4850, 0x10(%rax) # imm = 0x434D4850
movq 0x120(%rbx), %rax
movb %bpl, 0xfe(%rax)
movq 0x120(%rbx), %rax
movb %bpl, 0x14(%rax)
xorl %eax, %eax
cmpq $0x100, %rax            # imm = 0x100
je 0x9b46e
movb $-0x3, 0x15(%rbx,%rax)
incq %rax
jmp 0x9b45c
xorl %eax, %eax
leaq 0x4f09f(%rip), %rcx     # 0xea516
cmpq $0x14, %rax
je 0x9b48d
movsbq (%rax,%rcx), %rdx
movl %edx, %edx
movb %al, 0x15(%rbx,%rdx)
incq %rax
jmp 0x9b477
xorl %eax, %eax
leaq 0x4f077(%rip), %rcx     # 0xea50d
cmpq $0x8, %rax
je 0x9b4ad
movsbq (%rax,%rcx), %rdx
movl %edx, %edx
movb $-0x2, 0x15(%rbx,%rdx)
incq %rax
jmp 0x9b496
popq %rbx
popq %r14
popq %rbp
retq