LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x53950
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xfba1d
movq 0xb85ec(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x62670(%rip), %rsi     # 0x15e066
leaq 0x79eec(%rip), %rdx     # 0x1758e9
leaq 0x81098(%rip), %rcx     # 0x17ca9c
leaq 0x80f9b(%rip), %r8      # 0x17c9a6
movl $0x22, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfba1f
callq 0x45010
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x7ff29(%rip), %rdx     # 0x17b969
callq 0x51640
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x523f0
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xfbaa9
movq 0xb8560(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x625e4(%rip), %rsi     # 0x15e066
leaq 0x6f375(%rip), %rdx     # 0x16adfe
leaq 0x8101e(%rip), %rcx     # 0x17caae
leaq 0x8102a(%rip), %r8      # 0x17cac1
movl $0x6d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfbaab
movq 0x10(%rsp), %rdi
callq 0x4f0e0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x81013(%rip), %rsi     # 0x17cad8
callq 0x55930
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4f790
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0x6fb9d(%rip), %rdx     # 0x16b687
callq 0x51fc0
movq 0x10(%rsp), %rdi
leaq 0x6f4e4(%rip), %rsi     # 0x16afdf
callq 0x50970
movq 0x10(%rsp), %rdi
leaq 0xc4(%rip), %rsi        # 0xfbbd0
xorl %edx, %edx
callq 0x51120
movq 0x10(%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
callq 0x51d10
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0xb81be(%rip), %rdx     # 0x1b3cf0
callq 0x55e30
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4f100
movq 0x10(%rsp), %rdi
leaq 0x88125(%rip), %rsi     # 0x183c77
leaq 0xb81c7(%rip), %rdx     # 0x1b3d20
callq 0x55e30
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4f100
movq 0x10(%rsp), %rdi
callq 0x4f0e0
cmpl 0xc(%rsp), %eax
je 0xfbbb5
movq 0xb8454(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x624d8(%rip), %rsi     # 0x15e066
leaq 0x7709d(%rip), %rdx     # 0x172c32
leaq 0x80f12(%rip), %rcx     # 0x17caae
leaq 0x80f1e(%rip), %r8      # 0x17cac1
movl $0x7d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfbbb7
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x80ea6(%rip), %rdx     # 0x17cad8
callq 0x559c0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x7fc41(%rip), %rdx     # 0x17b88e
callq 0x559c0
movq %rax, 0x18(%rsp)
callq 0xc0b0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x45c30
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0xfbc9b
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe84e0
movl %eax, 0x34(%rsp)
jmp 0xfbcad
movq 0x10(%rsp), %rdi
callq 0xc490
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x80dfb(%rip), %rdx     # 0x17cad8
movl $0x1, %esi
callq 0x559c0
movq %rax, 0x20(%rsp)
callq 0xc0b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rsi
callq 0x463e0
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movaps 0x62763(%rip), %xmm1    # 0x15e480
movq 0x8(%rsp), %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x62761(%rip), %xmm1    # 0x15e490
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
callq 0x506d0
cmpl $0x0, 0x14(%rsp)
jge 0xfbd5f
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xe84e0
movl %eax, 0x34(%rsp)
jmp 0xfbd71
movq 0x18(%rsp), %rdi
callq 0xc490
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x7fccf(%rip), %rdx     # 0x17ba69
callq 0x559c0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x55c40
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0xfbfa0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl $0x8, %esi
callq 0x53950
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xfbe1a
movq 0xb81ef(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x62273(%rip), %rsi     # 0x15e066
leaq 0x6b8c1(%rip), %rdx     # 0x1676bb
leaq 0x80cea(%rip), %rcx     # 0x17caeb
leaq 0x80cb9(%rip), %r8      # 0x17cac1
movl $0x2a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfbe1c
callq 0xc0b0
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movl 0x14(%rsp), %esi
movq 0x8(%rsp), %rdx
movq (%rsp), %rcx
callq 0x456a0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0xfbe59
jmp 0xfbe6d
movq 0x28(%rsp), %rdi
movq (%rsp), %rsi
callq 0xe84e0
movl %eax, 0x34(%rsp)
jmp 0xfbea3
movq (%rsp), %rdi
callq 0xc490
movq 0x28(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0x80c51(%rip), %rdx     # 0x17cad8
callq 0x51640
movq 0x28(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x523f0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xfbece
cmpq $0x0, 0x8(%rsp)
jne 0xfbf06
movq 0xb8103(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x62187(%rip), %rsi     # 0x15e066
leaq 0x80c14(%rip), %rdx     # 0x17cafa
leaq 0x80c18(%rip), %rcx     # 0x17cb05
leaq 0x80c2e(%rip), %r8      # 0x17cb22
movl $0x1d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfbf08
movq 0x10(%rsp), %rdi
callq 0x4f0e0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
leaq -0xb46d2(%rip), %rsi    # 0x47850
callq 0x51390
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x51390
movq 0x10(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x52070
movq 0x10(%rsp), %rdi
callq 0x4f0e0
cmpl 0x4(%rsp), %eax
je 0xfbf8d
movq 0xb807c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x62100(%rip), %rsi     # 0x15e066
leaq 0x76cc5(%rip), %rdx     # 0x172c32
leaq 0x80b91(%rip), %rcx     # 0x17cb05
leaq 0x80ba7(%rip), %r8      # 0x17cb22
movl $0x24, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfbf8f
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xfbfe9
movq 0xb8020(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x620a4(%rip), %rsi     # 0x15e066
leaq 0x6ee35(%rip), %rdx     # 0x16adfe
leaq 0x80b72(%rip), %rcx     # 0x17cb42
leaq 0x80b4b(%rip), %r8      # 0x17cb22
movl $0x2d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfbfeb
movq 0x10(%rsp), %rdi
callq 0x4f0e0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq -0xb47b5(%rip), %rsi    # 0x47850
callq 0x51390
movq 0x10(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
callq 0x516f0
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4f800
cmpl $0x2, %eax
je 0xfc065
movq 0xb7fa4(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x62028(%rip), %rsi     # 0x15e066
leaq 0x80b1c(%rip), %rdx     # 0x17cb61
leaq 0x80af6(%rip), %rcx     # 0x17cb42
leaq 0x80acf(%rip), %r8      # 0x17cb22
movl $0x33, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfc067
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x50530
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4f100
movq 0x10(%rsp), %rdi
callq 0x4f0e0
cmpl 0xc(%rsp), %eax
je 0xfc0d1
movq 0xb7f38(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x61fbc(%rip), %rsi     # 0x15e066
leaq 0x76b81(%rip), %rdx     # 0x172c32
leaq 0x80a8a(%rip), %rcx     # 0x17cb42
leaq 0x80a63(%rip), %r8      # 0x17cb22
movl $0x36, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xfc0d3
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
movl $0x30, %r8d
callq 0xc3270
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xfc123
movq $0x0, 0x20(%rsp)
jmp 0xfc187
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %r8
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movl $0x1, %ecx
callq 0xc3270
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xfc15e
movq $0x0, 0x20(%rsp)
jmp 0xfc187
movl 0x14(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq (%rsp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0xfc0e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xfc1de
movq $0x0, 0x30(%rsp)
jmp 0xfc21d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movslq 0x24(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movslq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
movl $0x20, %edx
callq 0xfc0e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xfc277
movq $0x0, 0x30(%rsp)
jmp 0xfc2d8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x18(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x14(%rsp), %ecx
movq (%rsp), %rax
movb %cl, %dl
movb 0x10(%rax), %cl
andb $0x1, %dl
andb $-0x2, %cl
orb %dl, %cl
movb %cl, 0x10(%rax)
movq 0x20(%rsp), %rax
movl 0x18(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x3, %esi
movl $0x10, %edx
callq 0xfc0e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xfc32d
movq $0x0, 0x20(%rsp)
jmp 0xfc36e
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
movq 0x8(%rsp), %rax
addl 0x18(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq 0xfc0e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0xfc3bd
movq $0x0, 0x20(%rsp)
jmp 0xfc3fe
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
movq 0x8(%rsp), %rax
addl 0x18(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
shrl $0x18, %eax
movl %eax, %eax
andq $0xff, %rax
movl %eax, %edx
movl $0x8, %esi
callq 0xfc7f0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
shrl $0x10, %eax
movl %eax, %eax
andq $0xff, %rax
movl %eax, %edx
movl $0x8, %esi
callq 0xfc7f0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
shrl $0x8, %eax
movl %eax, %eax
andq $0xff, %rax
movl %eax, %edx
movl $0x8, %esi
callq 0xfc7f0
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %eax
andq $0xff, %rax
movl %eax, %edx
movl $0x8, %esi
callq 0xfc7f0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/bzip2-1.0.6/compress.c
// Function: bsFinishWrite
static
void bsFinishWrite ( EState* s )
{
   while (s->bsLive > 0) {
      s->zbits[s->numZ] = (UChar)(s->bsBuff >> 24);
      s->numZ++;
      s->bsBuff <<= 8;
      s->bsLive -= 8;
   }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x0, 0x284(%rax)
jle 0x101780
movq -0x8(%rsp), %rax
movl 0x280(%rax), %eax
shrl $0x18, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rsp), %rcx
movslq 0x74(%rcx), %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rsp), %rax
movl 0x74(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x74(%rax)
movq -0x8(%rsp), %rax
movl 0x280(%rax), %ecx
shll $0x8, %ecx
movl %ecx, 0x280(%rax)
movq -0x8(%rsp), %rax
movl 0x284(%rax), %ecx
subl $0x8, %ecx
movl %ecx, 0x284(%rax)
jmp 0x101715
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/bzip2-1.0.6/compress.c
// Function: makeMaps_e
static
void makeMaps_e ( EState* s )
{
   Int32 i;
   s->nInUse = 0;
   for (i = 0; i < 256; i++)
      if (s->inUse[i]) {
         s->unseqToSeq[i] = s->nInUse;
         s->nInUse++;
      }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0x7c(%rax)
movl $0x0, -0xc(%rsp)
cmpl $0x100, -0xc(%rsp)      # imm = 0x100
jge 0x1017ff
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
cmpb $0x0, 0x80(%rax,%rcx)
je 0x1017f0
movq -0x8(%rsp), %rax
movl 0x7c(%rax), %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movb %dl, 0x180(%rax,%rcx)
movq -0x8(%rsp), %rax
movl 0x7c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x7c(%rax)
jmp 0x1017f2
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1017a9
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/bzip2-1.0.6/decompress.c
// Function: makeMaps_d
static
void makeMaps_d ( DState* s )
{
   Int32 i;
   s->nInUse = 0;
   for (i = 0; i < 256; i++)
      if (s->inUse[i]) {
         s->seqToUnseq[s->nInUse] = i;
         s->nInUse++;
      }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, 0xc78(%rax)
movl $0x0, -0xc(%rsp)
cmpl $0x100, -0xc(%rsp)      # imm = 0x100
jge 0x10767b
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
cmpb $0x0, 0xc7c(%rax,%rcx)
je 0x10766c
movl -0xc(%rsp), %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq -0x8(%rsp), %rcx
movslq 0xc78(%rcx), %rcx
movb %dl, 0xd8c(%rax,%rcx)
movq -0x8(%rsp), %rax
movl 0xc78(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc78(%rax)
jmp 0x10766e
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x10761c
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
jge 0x107de6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, -0x8(%rsp)
jmp 0x107f10
movq -0x20(%rsp), %rax
movl $0xfff1, %ecx           # imm = 0xFFF1
cqto
idivq %rcx
movq %rdx, -0x20(%rsp)
movq -0x20(%rsp), %rax
movl %eax, -0x34(%rsp)
movq -0x10(%rsp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq %rax, -0x28(%rsp)
movl -0x34(%rsp), %eax
imulq -0x28(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x30(%rsp), %rax
movl $0xfff1, %ecx           # imm = 0xFFF1
xorl %edx, %edx
divq %rcx
movq %rdx, -0x30(%rsp)
movq -0x18(%rsp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
addq $0xfff1, %rax           # imm = 0xFFF1
subq $0x1, %rax
addq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
shrq $0x10, %rax
andq $0xffff, %rax           # imm = 0xFFFF
movq -0x18(%rsp), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
addq %rcx, %rax
addq $0xfff1, %rax           # imm = 0xFFF1
movl -0x34(%rsp), %ecx
subq %rcx, %rax
addq -0x30(%rsp), %rax
movq %rax, -0x30(%rsp)
cmpq $0xfff1, -0x28(%rsp)    # imm = 0xFFF1
jb 0x107ea9
movq -0x28(%rsp), %rax
subq $0xfff1, %rax           # imm = 0xFFF1
movq %rax, -0x28(%rsp)
cmpq $0xfff1, -0x28(%rsp)    # imm = 0xFFF1
jb 0x107ec4
movq -0x28(%rsp), %rax
subq $0xfff1, %rax           # imm = 0xFFF1
movq %rax, -0x28(%rsp)
cmpq $0x1ffe2, -0x30(%rsp)   # imm = 0x1FFE2
jb 0x107edf
movq -0x30(%rsp), %rax
subq $0x1ffe2, %rax          # imm = 0x1FFE2
movq %rax, -0x30(%rsp)
cmpq $0xfff1, -0x30(%rsp)    # imm = 0xFFF1
jb 0x107efa
movq -0x30(%rsp), %rax
subq $0xfff1, %rax           # imm = 0xFFF1
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq -0x30(%rsp), %rcx
shlq $0x10, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x8, -0xc(%rsp)
jge 0x108bd8
movq -0x8(%rsp), %rax
shrq $0x8, %rax
movq -0x8(%rsp), %rdx
andq $0xff, %rdx
leaq 0x741d0(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x108b9d
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/crc32.c
// Function: byte_swap
local z_word_t byte_swap(z_word_t word) {
#  if W == 8
    return
        (word & 0xff00000000000000) >> 56 |
        (word & 0xff000000000000) >> 40 |
        (word & 0xff0000000000) >> 24 |
        (word & 0xff00000000) >> 8 |
        (word & 0xff000000) << 8 |
        (word & 0xff0000) << 24 |
        (word & 0xff00) << 40 |
        (word & 0xff) << 56;
#  else   /* W == 4 */
    return
        (word & 0xff000000) >> 24 |
        (word & 0xff0000) >> 8 |
        (word & 0xff00) << 8 |
        (word & 0xff) << 24;
#  endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movabsq $-0x100000000000000, %rax # imm = 0xFF00000000000000
andq -0x8(%rsp), %rax
shrq $0x38, %rax
movabsq $0xff000000000000, %rcx # imm = 0xFF000000000000
andq -0x8(%rsp), %rcx
shrq $0x28, %rcx
orq %rcx, %rax
movabsq $0xff0000000000, %rcx   # imm = 0xFF0000000000
andq -0x8(%rsp), %rcx
shrq $0x18, %rcx
orq %rcx, %rax
movabsq $0xff00000000, %rcx     # imm = 0xFF00000000
andq -0x8(%rsp), %rcx
shrq $0x8, %rcx
orq %rcx, %rax
movabsq $0xff000000, %rcx       # imm = 0xFF000000
andq -0x8(%rsp), %rcx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0xff0000, %rcx         # imm = 0xFF0000
shlq $0x18, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0xff00, %rcx           # imm = 0xFF00
shlq $0x28, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
andq $0xff, %rcx
shlq $0x38, %rcx
orq %rcx, %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/crc32.c
// Function: crc_word_big
local z_word_t crc_word_big(z_word_t data) {
    int k;
    for (k = 0; k < W; k++)
        data = (data << 8) ^
            crc_big_table[(data >> ((W - 1) << 3)) & 0xff];
    return data;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x8, -0xc(%rsp)
jge 0x108cda
movq -0x8(%rsp), %rax
shlq $0x8, %rax
movq -0x8(%rsp), %rdx
shrq $0x38, %rdx
andq $0xff, %rdx
leaq 0x7a4cc(%rip), %rcx     # 0x183190
xorq (%rcx,%rdx,8), %rax
movq %rax, -0x8(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x108c9d
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/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:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl $0x80000000, -0xc(%rsp) # imm = 0x80000000
movl $0x0, -0x10(%rsp)
movl -0x4(%rsp), %eax
andl -0xc(%rsp), %eax
cmpl $0x0, %eax
je 0x108da7
movl -0x8(%rsp), %eax
xorl -0x10(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x4(%rsp), %eax
movl -0xc(%rsp), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
jne 0x108da5
jmp 0x108de2
jmp 0x108da7
movl -0xc(%rsp), %eax
shrl %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x108dce
movl -0x8(%rsp), %eax
shrl %eax
xorl $0xedb88320, %eax       # imm = 0xEDB88320
movl %eax, -0x14(%rsp)
jmp 0x108dd8
movl -0x8(%rsp), %eax
shrl %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x8(%rsp)
jmp 0x108d78
movl -0x10(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x80000000, 0x8(%rsp)  # imm = 0x80000000
cmpq $0x0, 0x10(%rsp)
je 0x108e58
movq 0x10(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x108e3e
movl 0xc(%rsp), %eax
andl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0x7ab62(%rip), %rax     # 0x183990
movl (%rax,%rcx,4), %edi
movl 0x8(%rsp), %esi
callq 0x108d60
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
sarq %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x108e05
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x109174
movq 0xaae95(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x54f19(%rip), %rsi     # 0x15e066
leaq 0x6f8f4(%rip), %rdx     # 0x178a48
leaq 0x7a8db(%rip), %rcx     # 0x183a36
leaq 0x7a8c0(%rip), %r8      # 0x183a22
movl $0x18a, %r9d            # imm = 0x18A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x109176
movq (%rsp), %rax
movq 0x128(%rax), %rdi
callq 0x1c340
movq (%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq (%rsp), %rax
movq 0x128(%rax), %rdi
callq 0x1c3e0
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1091cc
cmpq $0x0, (%rsp)
jne 0x109204
movq 0xaae05(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x54e89(%rip), %rsi     # 0x15e066
leaq 0x652d4(%rip), %rdx     # 0x16e4b8
leaq 0x7a85b(%rip), %rcx     # 0x183a46
leaq 0x7a830(%rip), %r8      # 0x183a22
movl $0x193, %r9d            # imm = 0x193
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x109206
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq (%rsp), %rcx
cmpl (%rcx), %eax
je 0x10921f
movb $0x0, 0x17(%rsp)
jmp 0x10930b
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movq (%rsp), %rcx
cmpl 0x4(%rcx), %eax
je 0x10923a
movb $0x0, 0x17(%rsp)
jmp 0x10930b
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movq (%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x109255
movb $0x0, 0x17(%rsp)
jmp 0x10930b
movq 0x8(%rsp), %rax
movzbl 0x14(%rax), %eax
movq (%rsp), %rcx
movzbl 0x14(%rcx), %ecx
cmpl %ecx, %eax
je 0x109274
movb $0x0, 0x17(%rsp)
jmp 0x10930b
movq 0x8(%rsp), %rdi
addq $0x15, %rdi
movq (%rsp), %rsi
addq $0x15, %rsi
movl $0xff, %edx
callq 0xb250
cmpl $0x0, %eax
je 0x10929b
movb $0x0, 0x17(%rsp)
jmp 0x10930b
movq 0x8(%rsp), %rax
movq 0x120(%rax), %rdi
movq (%rsp), %rax
movq 0x120(%rax), %rsi
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0xb250
cmpl $0x0, %eax
je 0x1092d1
movb $0x0, 0x17(%rsp)
jmp 0x10930b
movq 0x8(%rsp), %rax
movq 0x118(%rax), %rdi
movq (%rsp), %rax
movq 0x118(%rax), %rsi
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
shlq $0x0, %rdx
callq 0xb250
cmpl $0x0, %eax
je 0x109306
movb $0x0, 0x17(%rsp)
jmp 0x10930b
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x109570
movq 0xaaa99(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x54b1d(%rip), %rsi     # 0x15e066
leaq 0x6f4f8(%rip), %rdx     # 0x178a48
leaq 0x7a543(%rip), %rcx     # 0x183a9a
leaq 0x7a4c4(%rip), %r8      # 0x183a22
movl $0x1bd, %r9d            # imm = 0x1BD
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x109572
movq 0x10(%rsp), %rax
movq 0x118(%rax), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, %esi
addq $0x1, %rsi
leaq 0x7a490(%rip), %rdx     # 0x183a22
movl $0x1bf, %ecx            # imm = 0x1BF
callq 0xd730
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x118(%rax)
movb 0xf(%rsp), %dl
movq 0x10(%rsp), %rax
movq 0x118(%rax), %rax
movq 0x10(%rsp), %rcx
movl (%rcx), %ecx
movb %dl, (%rax,%rcx)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movsbl 0xf(%rsp), %ecx
movslq %ecx, %rcx
movb $-0x2, 0x15(%rax,%rcx)
movq 0x10(%rsp), %rax
movzbl 0x14(%rax), %eax
cmpl $0xfd, %eax
jne 0x10960d
movb 0xf(%rsp), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x14(%rax)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x109686
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x10964e
jmp 0x109686
movq 0xaa983(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x54a07(%rip), %rsi     # 0x15e066
leaq 0x54fe2(%rip), %rdx     # 0x15e648
leaq 0x7a446(%rip), %rcx     # 0x183ab3
leaq 0x7a3ae(%rip), %r8      # 0x183a22
movl $0x246, %r9d            # imm = 0x246
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x109688
callq 0x109730
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x1097f0
cmpl $0x0, %eax
je 0x1096fd
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x1096f9
movq 0xaa910(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x54994(%rip), %rsi     # 0x15e066
leaq 0x8135f(%rip), %rdx     # 0x18aa38
leaq 0x7a3d3(%rip), %rcx     # 0x183ab3
leaq 0x7a33b(%rip), %r8      # 0x183a22
movl $0x24b, %r9d            # imm = 0x24B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1096fb
jmp 0x1096fd
cmpl $0x0, 0x4(%rsp)
je 0x109719
movq 0x8(%rsp), %rdi
callq 0x1098b0
movq $0x0, 0x20(%rsp)
jmp 0x109723
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x138, %edi            # imm = 0x138
leaq 0x7a2e5(%rip), %rsi     # 0x183a22
movl $0x269, %edx            # imm = 0x269
callq 0xd2e0
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movq (%rsp), %rax
movl $0x0, 0xc(%rax)
movq (%rsp), %rax
movl $0x0, 0x10(%rax)
callq 0x1c240
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x128(%rax)
movq (%rsp), %rax
movb $-0x3, 0x14(%rax)
movq (%rsp), %rdi
addq $0x15, %rdi
movl $0xfd, %esi
movl $0x100, %edx            # imm = 0x100
callq 0xb2d0
movq (%rsp), %rax
movq $0x0, 0x118(%rax)
movq (%rsp), %rax
movq $0x0, 0x120(%rax)
movq (%rsp), %rax
movq $0x0, 0x130(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/alphabet.c
// Function: assign_protein_or_dna_alphabet
static int assign_protein_or_dna_alphabet(GtAlphabet *alpha,
                                          const GtStrArray *filenametab,
                                          GtError *err)
{
  int retval;

  gt_error_check(err);
  retval = gt_files_guess_if_protein_sequences(filenametab,err);
  if (retval < 0)
  {
    return -1;
  }
  if (retval == 1)
  {
    assign_protein_alphabet(alpha);
  } else
  {
    assign_dna_alphabet(alpha);
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x109853
movq 0x8(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x10981b
jmp 0x109853
movq 0xaa7b6(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x5483a(%rip), %rsi     # 0x15e066
leaq 0x54e15(%rip), %rdx     # 0x15e648
leaq 0x7a67f(%rip), %rcx     # 0x183eb9
leaq 0x7a1e1(%rip), %r8      # 0x183a22
movl $0x231, %r9d            # imm = 0x231
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x109855
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x85050
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x109879
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x10989e
cmpl $0x1, 0x4(%rsp)
jne 0x10988c
movq 0x18(%rsp), %rdi
callq 0x109b50
jmp 0x109896
movq 0x18(%rsp), %rdi
callq 0x1099f0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1098c1
jmp 0x109988
movq (%rsp), %rax
movq 0x128(%rax), %rdi
callq 0x1c340
movq (%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x1098fd
movq (%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq (%rsp), %rax
movq 0x128(%rax), %rdi
callq 0x1c3e0
jmp 0x109988
movq (%rsp), %rax
movq 0x128(%rax), %rdi
callq 0x1c3e0
movq (%rsp), %rax
movq 0x118(%rax), %rdi
leaq 0x7a103(%rip), %rsi     # 0x183a22
movl $0x444, %edx            # imm = 0x444
callq 0xdab0
movq (%rsp), %rax
movq 0x120(%rax), %rdi
leaq 0x7a0e7(%rip), %rsi     # 0x183a22
movl $0x445, %edx            # imm = 0x445
callq 0xdab0
movq (%rsp), %rax
cmpq $0x0, 0x130(%rax)
je 0x109963
movq (%rsp), %rax
movq 0x130(%rax), %rdi
callq 0x1afc0
movq (%rsp), %rax
movq 0x128(%rax), %rdi
callq 0x1c2c0
movq (%rsp), %rdi
leaq 0x7a0a4(%rip), %rsi     # 0x183a22
movl $0x449, %edx            # imm = 0x449
callq 0xdab0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
callq 0x109730
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1099d9
movq 0xaa630(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x546b4(%rip), %rsi     # 0x15e066
leaq 0x63b6b(%rip), %rdx     # 0x16d524
leaq 0x7a111(%rip), %rcx     # 0x183ad1
leaq 0x7a05b(%rip), %r8      # 0x183a22
movl $0x259, %r9d            # imm = 0x259
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1099db
movq (%rsp), %rdi
callq 0x1099f0
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movb 0x7a4e7(%rip), %cl      # 0x183ee2
movq (%rsp), %rax
movb %cl, 0x14(%rax)
movq (%rsp), %rax
movl $0x16, 0x8(%rax)
movq (%rsp), %rax
movl $0x20, (%rax)
movq (%rsp), %rax
movl $0x3, 0xc(%rax)
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, %edi
shlq $0x0, %rdi
leaq 0x79fed(%rip), %rsi     # 0x183a22
movl $0x1dd, %edx            # imm = 0x1DD
callq 0xd2e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x118(%rax)
movq (%rsp), %rax
movq 0x118(%rax), %rdi
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
leaq 0x7a471(%rip), %rsi     # 0x183ed8
callq 0xb500
movq (%rsp), %rax
movl $0x5, 0x4(%rax)
movl $0x100, %edi            # imm = 0x100
movl $0x1, %esi
leaq 0x79f9a(%rip), %rdx     # 0x183a22
movl $0x1e1, %ecx            # imm = 0x1E1
callq 0xd5b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x120(%rax)
movq (%rsp), %rax
movq 0x120(%rax), %rax
movl 0x7a1c4(%rip), %ecx     # 0x183c75
movl %ecx, (%rax)
movb 0x7a429(%rip), %cl      # 0x183ee2
movq (%rsp), %rax
movq 0x120(%rax), %rax
movb %cl, 0xfe(%rax)
movb 0x7a412(%rip), %cl      # 0x183ee2
movq (%rsp), %rax
movq 0x120(%rax), %rax
movb %cl, 0x4(%rax)
movq (%rsp), %rdi
addq $0x15, %rdi
callq 0x10a970
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
callq 0x109730
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x109b39
movq 0xaa4d0(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x54554(%rip), %rsi     # 0x15e066
leaq 0x63a0b(%rip), %rdx     # 0x16d524
leaq 0x79fc5(%rip), %rcx     # 0x183ae5
leaq 0x79efb(%rip), %r8      # 0x183a22
movl $0x262, %r9d            # imm = 0x262
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x109b3b
movq (%rsp), %rdi
callq 0x109b50
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movb 0x7a3b2(%rip), %cl      # 0x183f0d
movq (%rsp), %rax
movb %cl, 0x14(%rax)
movq (%rsp), %rax
movl $0x1c, (%rax)
movq (%rsp), %rax
movl $0x8, 0x8(%rax)
movq (%rsp), %rax
movl $0x5, 0xc(%rax)
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, %edi
shlq $0x0, %rdi
leaq 0x79e8d(%rip), %rsi     # 0x183a22
movl $0x220, %edx            # imm = 0x220
callq 0xd2e0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x118(%rax)
movq (%rsp), %rax
movq 0x118(%rax), %rdi
movq (%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
leaq 0x7a332(%rip), %rsi     # 0x183ef9
callq 0xb500
movq (%rsp), %rax
movl $0x15, 0x4(%rax)
movl $0x100, %edi            # imm = 0x100
movl $0x1, %esi
leaq 0x79e3a(%rip), %rdx     # 0x183a22
movl $0x224, %ecx            # imm = 0x224
callq 0xd5b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x120(%rax)
movq (%rsp), %rax
movq 0x120(%rax), %rax
movq 0x7a304(%rip), %rcx     # 0x183f16
movq %rcx, (%rax)
movq 0x7a302(%rip), %rcx     # 0x183f1e
movq %rcx, 0x8(%rax)
movl 0x7a300(%rip), %ecx     # 0x183f26
movl %ecx, 0x10(%rax)
movb 0x7a2de(%rip), %cl      # 0x183f0d
movq (%rsp), %rax
movq 0x120(%rax), %rax
movb %cl, 0xfe(%rax)
movb 0x7a2c7(%rip), %cl      # 0x183f0d
movq (%rsp), %rax
movq 0x120(%rax), %rax
movb %cl, 0x14(%rax)
movq (%rsp), %rdi
addq $0x15, %rdi
callq 0x10bda0
popq %rax
retq
nopw %cs:(%rax,%rax)