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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xaf559
movq 0x104ab0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xaeb34(%rip), %rsi     # 0x15e066
leaq 0xbb8c5(%rip), %rdx     # 0x16adfe
leaq 0xc4818(%rip), %rcx     # 0x173d58
leaq 0xc482a(%rip), %r8      # 0x173d71
movl $0x83, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xaf55b
movq 0x10(%rsp), %rdi
callq 0x4f0e0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xc4819(%rip), %rsi     # 0x173d8e
callq 0x55930
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4f790
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xbc0ed(%rip), %rdx     # 0x16b687
callq 0x51fc0
movq 0x10(%rsp), %rdi
leaq 0xbba34(%rip), %rsi     # 0x16afdf
callq 0x50970
movq 0x10(%rsp), %rdi
leaq 0xc4(%rip), %rsi        # 0xaf680
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 0x103b6e(%rip), %rdx    # 0x1b3150
callq 0x55e30
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4f100
movq 0x10(%rsp), %rdi
leaq 0xd4675(%rip), %rsi     # 0x183c77
leaq 0x103b87(%rip), %rdx    # 0x1b3190
callq 0x55e30
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4f100
movq 0x10(%rsp), %rdi
callq 0x4f0e0
cmpl 0xc(%rsp), %eax
je 0xaf665
movq 0x1049a4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xaea28(%rip), %rsi     # 0x15e066
leaq 0xc35ed(%rip), %rdx     # 0x172c32
leaq 0xc470c(%rip), %rcx     # 0x173d58
leaq 0xc471e(%rip), %r8      # 0x173d71
movl $0x94, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xaf667
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/gtlua/score_matrix_lua.c
// Function: score_matrix_lua_get_dimension
static int score_matrix_lua_get_dimension(lua_State *L)
{
  GtScoreMatrix **sm;
  unsigned int dimension;
  sm = check_score_matrix(L, 1);
  dimension = gt_score_matrix_get_dimension(*sm);
  lua_pushinteger(L, dimension);
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
leaq 0xc46b4(%rip), %rdx     # 0x173d8e
callq 0x559c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xe24e0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movl 0x4(%rsp), %eax
movl %eax, %esi
callq 0x50720
movl $0x1, %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/gtlua/score_matrix_lua.c
// Function: score_matrix_lua_get_score
static int score_matrix_lua_get_score(lua_State *L)
{
  GtScoreMatrix **sm;
  int idx1, idx2;
  int score;
  sm = check_score_matrix(L, 1);
  idx1 = luaL_checkint(L, 2);
  idx2 = luaL_checkint(L, 3);
  luaL_argcheck(L, idx1 >= 0, 2, "idx1 too small");
  luaL_argcheck(L, idx2 >= 0, 3, "idx2 too small");
  luaL_argcheck(L, idx1 < gt_score_matrix_get_dimension(*sm), 2,
                "idx1 too large");
  luaL_argcheck(L, idx2 < gt_score_matrix_get_dimension(*sm), 3,
                "idx2 too large");
  score = gt_score_matrix_get_score(*sm, idx1, idx2);
  lua_pushinteger(L, score);
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movl $0x1, %esi
leaq 0xc4664(%rip), %rdx     # 0x173d8e
callq 0x559c0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movl $0x2, %esi
callq 0x55c40
movl %eax, 0x24(%rsp)
movq 0x30(%rsp), %rdi
movl $0x3, %esi
callq 0x55c40
movl %eax, 0x20(%rsp)
movb $0x1, %al
cmpl $0x0, 0x24(%rsp)
movb %al, 0x1b(%rsp)
jge 0xaf787
movq 0x30(%rsp), %rdi
movl $0x2, %esi
leaq 0xc462f(%rip), %rdx     # 0x173da7
callq 0x55420
cmpl $0x0, %eax
setne %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
movb $0x1, %al
cmpl $0x0, 0x20(%rsp)
movb %al, 0x1a(%rsp)
jge 0xaf7b8
movq 0x30(%rsp), %rdi
movl $0x3, %esi
leaq 0xc460d(%rip), %rdx     # 0x173db6
callq 0x55420
cmpl $0x0, %eax
setne %al
movb %al, 0x1a(%rsp)
movb 0x1a(%rsp), %al
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0xe24e0
movl 0x14(%rsp), %ecx
movl %eax, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, 0x19(%rsp)
jb 0xaf801
movq 0x30(%rsp), %rdi
movl $0x2, %esi
leaq 0xc45d3(%rip), %rdx     # 0x173dc5
callq 0x55420
cmpl $0x0, %eax
setne %al
movb %al, 0x19(%rsp)
movb 0x19(%rsp), %al
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0xe24e0
movl 0xc(%rsp), %ecx
movl %eax, %edx
movb $0x1, %al
cmpl %edx, %ecx
movb %al, 0x13(%rsp)
jb 0xaf84a
movq 0x30(%rsp), %rdi
movl $0x3, %esi
leaq 0xc4599(%rip), %rdx     # 0x173dd4
callq 0x55420
cmpl $0x0, %eax
setne %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
callq 0xe2530
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0x50720
movl $0x1, %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/gtlua/score_matrix_lua.c
// Function: score_matrix_lua_new_read_protein
static int score_matrix_lua_new_read_protein(lua_State *L)
{
  GtScoreMatrix **sm;
  const char *path;
  GtError *err;
  gt_assert(L);
  path = luaL_checkstring(L, 1);
  sm = lua_newuserdata(L, sizeof (GtScoreMatrix*));
  gt_assert(sm);
  err = gt_error_new();
  if (!(*sm = gt_score_matrix_new_read_protein(path, err)))
    return gt_lua_error(L, err); /* handle error */
  gt_error_delete(err);
  gt_assert(*sm);
  luaL_getmetatable(L, SCOREMATRIX_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xaf919
movq 0x1046f0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae774(%rip), %rsi     # 0x15e066
leaq 0xbb505(%rip), %rdx     # 0x16adfe
leaq 0xc44e3(%rip), %rcx     # 0x173de3
leaq 0xc446a(%rip), %r8      # 0x173d71
movl $0x21, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xaf91b
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x558e0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x8, %esi
callq 0x53950
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xaf987
movq 0x104682(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae706(%rip), %rsi     # 0x15e066
leaq 0xc449f(%rip), %rdx     # 0x173e06
leaq 0xc4475(%rip), %rcx     # 0x173de3
leaq 0xc43fc(%rip), %r8      # 0x173d71
movl $0x24, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xaf989
callq 0xc0b0
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xe2020
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xaf9c2
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0xe84e0
movl %eax, 0x24(%rsp)
jmp 0xafa3d
movq (%rsp), %rdi
callq 0xc490
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xafa0e
movq 0x1045fb(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae67f(%rip), %rsi     # 0x15e066
leaq 0xc4417(%rip), %rdx     # 0x173e05
leaq 0xc43ee(%rip), %rcx     # 0x173de3
leaq 0xc4375(%rip), %r8      # 0x173d71
movl $0x29, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xafa10
movq 0x18(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0xc436d(%rip), %rdx     # 0x173d8e
callq 0x51640
movq 0x18(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x523f0
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/gtlua/score_matrix_lua.c
// Function: score_matrix_lua_new_read
static int score_matrix_lua_new_read(lua_State *L)
{
  GtScoreMatrix **sm;
  GtAlphabet **alpha;
  const char *path;
  GtError *err;
  gt_assert(L);
  path = luaL_checkstring(L, 1);
  alpha = check_alphabet(L, 2);
  sm = lua_newuserdata(L, sizeof (GtScoreMatrix*));
  gt_assert(sm);
  err = gt_error_new();
  if (!(*sm = gt_score_matrix_new_read(path, *alpha, err)))
    return gt_lua_error(L, err); /* handle error */
  gt_error_delete(err);
  gt_assert(*sm);
  luaL_getmetatable(L, SCOREMATRIX_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xafa99
movq 0x104570(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae5f4(%rip), %rsi     # 0x15e066
leaq 0xbb385(%rip), %rdx     # 0x16adfe
leaq 0xc4389(%rip), %rcx     # 0x173e09
leaq 0xc42ea(%rip), %r8      # 0x173d71
movl $0x35, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xafa9b
movq 0x28(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x558e0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0xc435f(%rip), %rdx     # 0x173e23
callq 0x559c0
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movl $0x8, %esi
callq 0x53950
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xafb22
movq 0x1044e7(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae56b(%rip), %rsi     # 0x15e066
leaq 0xc4304(%rip), %rdx     # 0x173e06
leaq 0xc4300(%rip), %rcx     # 0x173e09
leaq 0xc4261(%rip), %r8      # 0x173d71
movl $0x39, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xafb24
callq 0xc0b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0xe23e0
movq 0x20(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xafb68
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xe84e0
movl %eax, 0x34(%rsp)
jmp 0xafbe4
movq 0x8(%rsp), %rdi
callq 0xc490
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xafbb5
movq 0x104454(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae4d8(%rip), %rsi     # 0x15e066
leaq 0xc4270(%rip), %rdx     # 0x173e05
leaq 0xc426d(%rip), %rcx     # 0x173e09
leaq 0xc41ce(%rip), %r8      # 0x173d71
movl $0x3e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xafbb7
movq 0x28(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0xc41c6(%rip), %rdx     # 0x173d8e
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/gtlua/stream_evaluator_lua.c
// Function: gt_lua_open_stream_evaluator
int gt_lua_open_stream_evaluator(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_newmetatable(L, STREAM_EVALUATOR_METATABLE);
  /* metatable.__index = metatable */
  lua_pushvalue(L, -1); /* duplicate the metatable */
  lua_setfield(L, -2, "__index");
  /* set its _gc field */
  lua_pushstring(L, "__gc");
  lua_pushcfunction(L, stream_evaluator_lua_delete);
  lua_settable(L, -3);
  /* register functions */
  luaL_register(L, NULL, stream_evaluator_lib_m);
  lua_pop(L, 1);
  luaL_register(L, "gt", stream_evaluator_lib_f);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xafc39
movq 0x1043d0(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae454(%rip), %rsi     # 0x15e066
leaq 0xbb1e5(%rip), %rdx     # 0x16adfe
leaq 0xc4218(%rip), %rcx     # 0x173e38
leaq 0xc422e(%rip), %r8      # 0x173e55
movl $0x62, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xafc3b
movq 0x10(%rsp), %rdi
callq 0x4f0e0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xc4221(%rip), %rsi     # 0x173e76
callq 0x55930
movq 0x10(%rsp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x4f790
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xbba0d(%rip), %rdx     # 0x16b687
callq 0x51fc0
movq 0x10(%rsp), %rdi
leaq 0xbb354(%rip), %rsi     # 0x16afdf
callq 0x50970
movq 0x10(%rsp), %rdi
leaq 0xc4(%rip), %rsi        # 0xafd60
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 0x1034fe(%rip), %rdx    # 0x1b31c0
callq 0x55e30
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4f100
movq 0x10(%rsp), %rdi
leaq 0xd3f95(%rip), %rsi     # 0x183c77
leaq 0x103507(%rip), %rdx    # 0x1b31f0
callq 0x55e30
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4f100
movq 0x10(%rsp), %rdi
callq 0x4f0e0
cmpl 0xc(%rsp), %eax
je 0xafd45
movq 0x1042c4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae348(%rip), %rsi     # 0x15e066
leaq 0xc2f0d(%rip), %rdx     # 0x172c32
leaq 0xc410c(%rip), %rcx     # 0x173e38
leaq 0xc4122(%rip), %r8      # 0x173e55
movl $0x73, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xafd47
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/gtlua/stream_evaluator_lua.c
// Function: stream_evaluator_lua_evaluate
static int stream_evaluator_lua_evaluate(lua_State *L)
{
  GtStreamEvaluator **stream_evaluator;
  GtNodeVisitor **genome_visitor;
  GtError *err;
  stream_evaluator = check_stream_evaluator(L);
  if (lua_gettop(L) >= 2) {
    genome_visitor = check_genome_visitor(L, 2);
  }
  else
    genome_visitor = NULL;
  err = gt_error_new();
  if (gt_stream_evaluator_evaluate(*stream_evaluator, false, false, false,
                                   genome_visitor ? *genome_visitor : NULL,
                                   err)) {
    return gt_lua_error(L, err);
  }
  gt_error_delete(err);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0xc40bc(%rip), %rdx     # 0x173e76
callq 0x559c0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4f0e0
cmpl $0x2, %eax
jl 0xafdf0
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0xc399e(%rip), %rdx     # 0x173782
callq 0x559c0
movq %rax, 0x18(%rsp)
jmp 0xafdf9
movq $0x0, 0x18(%rsp)
callq 0xc0b0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xafe26
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
jmp 0xafe2e
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0xafe2e
movq 0x8(%rsp), %rdi
movq (%rsp), %r8
movq 0x10(%rsp), %r9
xorl %ecx, %ecx
movl %ecx, %esi
movl %ecx, %edx
callq 0xec600
cmpl $0x0, %eax
je 0xafe61
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xe84e0
movl %eax, 0x34(%rsp)
jmp 0xafe73
movq 0x10(%rsp), %rdi
callq 0xc490
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/gtlua/stream_evaluator_lua.c
// Function: stream_evaluator_lua_new
static int stream_evaluator_lua_new(lua_State *L)
{
  GtStreamEvaluator **stream_evaluator;
  GtNodeStream **reality_stream, **prediction_stream;
  reality_stream = check_genome_stream(L, 1);
  prediction_stream = check_genome_stream(L, 2);
  stream_evaluator = lua_newuserdata(L, sizeof (GtStreamEvaluator*));
  *stream_evaluator = gt_stream_evaluator_new(*reality_stream,
                                              *prediction_stream,
                                              true, false, 0);
  luaL_getmetatable(L, STREAM_EVALUATOR_METATABLE);
  lua_setmetatable(L, -2);
  return 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0x1, %esi
leaq 0xc3fce(%rip), %rdx     # 0x173ea8
callq 0x559c0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movl $0x2, %esi
leaq 0xc3fb3(%rip), %rdx     # 0x173ea8
callq 0x559c0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl $0x8, %esi
callq 0x53950
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0xebfc0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
movl $0xffffd8f0, %esi       # imm = 0xFFFFD8F0
leaq 0xc3f26(%rip), %rdx     # 0x173e76
callq 0x51640
movq 0x20(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x523f0
movl $0x1, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/gtlua/translate_lua.c
// Function: gt_lua_open_translate
int gt_lua_open_translate(lua_State *L)
{
#ifndef NDEBUG
  int stack_size;
#endif
  gt_assert(L);
#ifndef NDEBUG
  stack_size = lua_gettop(L);
#endif
  luaL_register(L, "gt", translate_lib_f);
  lua_pop(L, 1);
  gt_assert(lua_gettop(L) == stack_size);
  return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0xaffb9
movq 0x104050(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae0d4(%rip), %rsi     # 0x15e066
leaq 0xbae65(%rip), %rdx     # 0x16adfe
leaq 0xc3f22(%rip), %rcx     # 0x173ec2
leaq 0xc3f31(%rip), %r8      # 0x173ed8
movl $0x4f, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xaffbb
movq 0x10(%rsp), %rdi
callq 0x4f0e0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
leaq 0xd3ca2(%rip), %rsi     # 0x183c77
leaq 0x103234(%rip), %rdx    # 0x1b3210
callq 0x55e30
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x4f100
movq 0x10(%rsp), %rdi
callq 0x4f0e0
cmpl 0xc(%rsp), %eax
je 0xb0038
movq 0x103fd1(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xae055(%rip), %rsi     # 0x15e066
leaq 0xc2c1a(%rip), %rdx     # 0x172c32
leaq 0xc3ea3(%rip), %rcx     # 0x173ec2
leaq 0xc3eb2(%rip), %r8      # 0x173ed8
movl $0x55, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb003a
movl $0x1, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/gtlua/translate_lua.c
// Function: translate_dna_lua
static int translate_dna_lua(lua_State *L)
{
  int had_err = 0;
  GtStr *protein;
  GtTranslator *tr;
  GtTranslatorStatus status;
  char translated;
  GtError *err;
  unsigned int frame;
  const char *dna = luaL_checkstring(L, 1);
  luaL_argcheck(L, strlen(dna) >= 3, 1,
                "string to translate must at least be one codon");
  protein = gt_str_new();

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

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

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

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movq 0x58(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x558e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb240
movq %rax, %rcx
movb $0x1, %al
cmpq $0x3, %rcx
movb %al, 0x17(%rsp)
jae 0xb00b2
movq 0x58(%rsp), %rdi
movl $0x1, %esi
leaq 0xc3e5d(%rip), %rdx     # 0x173f00
callq 0x55420
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
callq 0x18f00
movq %rax, 0x48(%rsp)
callq 0xc0b0
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb240
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
callq 0xe0180
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xb011f
movq 0x48(%rsp), %rdi
callq 0x1afc0
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xe84e0
movl %eax, 0x64(%rsp)
jmp 0xb0201
movq 0x18(%rsp), %rdi
callq 0xe59b0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rcx
leaq 0x3b(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0xe60e0
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0xb0187
cmpl $0x0, 0x2c(%rsp)
jne 0xb0168
movq 0x48(%rsp), %rdi
movsbl 0x3b(%rsp), %esi
callq 0x194d0
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rcx
leaq 0x3b(%rsp), %rsi
leaq 0x2c(%rsp), %rdx
callq 0xe60e0
movl %eax, 0x3c(%rsp)
jmp 0xb014b
cmpl $-0x2, 0x3c(%rsp)
jne 0xb0196
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x54(%rsp)
je 0xb01b2
movq 0x58(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xe84e0
movl %eax, 0x64(%rsp)
jmp 0xb0201
movq 0x30(%rsp), %rdi
callq 0xc490
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x19940
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x50970
movq 0x48(%rsp), %rdi
callq 0x1afc0
movq 0x40(%rsp), %rdi
callq 0xe6310
movq 0x18(%rsp), %rdi
callq 0xdfde0
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_compare
int gt_block_compare(const GtBlock *block1, const GtBlock *block2,
                     GT_UNUSED void *data)
{
  GtRange range_a, range_b;
  int ret = 0;
  gt_assert(block1 && block2);
  range_a = gt_block_get_range(block1),
  range_b = gt_block_get_range(block2);
  ret = gt_range_compare(&range_a, &range_b);
  if (ret == 0 && block1 != block2) {
    GtStr *caption1, *caption2;
    caption1 = gt_block_get_caption(block1);
    caption2 = gt_block_get_caption(block2);
    /* blocks do not necessarily have captions. If both have a caption, we
       compare them. If only one block has a caption, this block comes first. */
    if (caption1 && caption2)
      ret = strcmp(gt_str_get(caption1), gt_str_get(caption2));
    else if (caption1)
      ret = -1;
    else if (caption2)
      ret = 1;
  }
  return ret;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl $0x0, 0x3c(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0xb023b
cmpq $0x0, 0x68(%rsp)
jne 0xb0273
movq 0x103d96(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xade1a(%rip), %rsi     # 0x15e066
leaq 0xc3cdc(%rip), %rdx     # 0x173f2f
leaq 0xc3ce6(%rip), %rcx     # 0x173f40
leaq 0xc3cf0(%rip), %r8      # 0x173f51
movl $0x5d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb0275
movq 0x70(%rsp), %rdi
callq 0xb0380
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rdi
callq 0xb0380
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x93850
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0xb0373
movq 0x70(%rsp), %rax
cmpq 0x68(%rsp), %rax
je 0xb0373
movq 0x70(%rsp), %rdi
callq 0xb03f0
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0xb03f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xb034b
cmpq $0x0, 0x8(%rsp)
je 0xb034b
movq 0x10(%rsp), %rdi
callq 0x19940
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x19940
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xb850
movl %eax, 0x3c(%rsp)
jmp 0xb0371
cmpq $0x0, 0x10(%rsp)
je 0xb035d
movl $0xffffffff, 0x3c(%rsp) # imm = 0xFFFFFFFF
jmp 0xb036f
cmpq $0x0, 0x8(%rsp)
je 0xb036d
movl $0x1, 0x3c(%rsp)
jmp 0xb036f
jmp 0xb0371
jmp 0xb0373
movl 0x3c(%rsp), %eax
addq $0x78, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_print
void gt_block_print(const GtBlock* block)
{
  GtUword i;
  gt_assert(block);
  for (i=0;i<gt_array_size(block->elements);i++)
  {
    GtElement *elem;
    elem = gt_element_ref(*(GtElement**) gt_array_get(block->elements, i));
    gt_assert(elem);
    GtRange r = gt_element_get_range(elem);
    printf("%s\t"GT_WU"-"GT_WU"\n", gt_element_get_type(elem),
                           r.start,
                           r.end);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0xb04e9
movq 0x103b20(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xadba4(%rip), %rsi     # 0x15e066
leaq 0xc49c6(%rip), %rdx     # 0x174e8f
leaq 0xc3aab(%rip), %rcx     # 0x173f7b
leaq 0xc3a7a(%rip), %r8      # 0x173f51
movl $0x7b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb04eb
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xb05c9
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x75c80
movq (%rax), %rdi
callq 0xb6cc0
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xb057b
movq 0x103a8e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xadb12(%rip), %rsi     # 0x15e066
leaq 0xbbedf(%rip), %rdx     # 0x16c43a
leaq 0xc3a19(%rip), %rcx     # 0x173f7b
leaq 0xc39e8(%rip), %r8      # 0x173f51
movl $0x80, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb057d
movq 0x20(%rsp), %rdi
callq 0xb6d20
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xb6d90
movq %rax, %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
leaq 0xc39db(%rip), %rdi     # 0x173f8a
movb $0x0, %al
callq 0xb070
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xb04f4
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_new
GtBlock* gt_block_new(void)
{
  GtBlock *block = gt_calloc(1, sizeof (GtBlock));
  block->elements = gt_array_new(sizeof (GtElement*));
  block->caption = NULL;
  block->show_caption = true;
  block->sorted = false;
  block->strand = GT_STRAND_UNKNOWN;
  block->top_level_feature = NULL;
  return block;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x48, %esi
leaq 0xc396f(%rip), %rdx     # 0x173f51
movl $0x8a, %ecx
callq 0xd5b0
movq %rax, (%rsp)
movl $0x8, %edi
callq 0x75ab0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
movb $0x1, 0x28(%rax)
movq (%rsp), %rax
movb $0x0, 0x29(%rax)
movq (%rsp), %rax
movl $0x3, 0x2c(%rax)
movq (%rsp), %rax
movq $0x0, 0x38(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_new_from_node
GtBlock* gt_block_new_from_node(GtFeatureNode *node)
{
  GtBlock *block;
  gt_assert(node);
  block = gt_block_new();
  block->range = gt_genome_node_get_range((GtGenomeNode*) node);
  block->strand = gt_feature_node_get_strand(node);
  block->type = gt_feature_node_get_type(node);
  if (!gt_feature_node_is_pseudo(node)) {
    block->top_level_feature = (GtFeatureNode*)
                               gt_genome_node_ref((GtGenomeNode*) node);
  }
  return block;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xb0689
movq 0x103980(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xada04(%rip), %rsi     # 0x15e066
leaq 0xb74a9(%rip), %rdx     # 0x167b12
leaq 0xc3926(%rip), %rcx     # 0x173f96
leaq 0xc38da(%rip), %r8      # 0x173f51
movl $0x97, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb068b
callq 0xb05d0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x259f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rdi
callq 0x20a10
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x2c(%rax)
movq 0x20(%rsp), %rdi
callq 0x211d0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rsp), %rdi
callq 0x21880
testb $0x1, %al
jne 0xb0719
movq 0x20(%rsp), %rdi
callq 0x25140
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_insert_element
void gt_block_insert_element(GtBlock *block, GtFeatureNode *node)
{
  GtElement *element;
  gt_assert(block && node);
  if (!block->top_level_feature) {
    block->top_level_feature = (GtFeatureNode*)
                               gt_genome_node_ref((GtGenomeNode*) node);
  }
  element = gt_element_new(node);
  /* invalidate sortedness flag because insertion of element at the end
     may break ordering */
  block->sorted = false;
  gt_array_add(block->elements, element);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xb074e
cmpq $0x0, 0x8(%rsp)
jne 0xb0786
movq 0x103883(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xad907(%rip), %rsi     # 0x15e066
leaq 0xc3847(%rip), %rdx     # 0x173fad
leaq 0xc384e(%rip), %rcx     # 0x173fbb
leaq 0xc37dd(%rip), %r8      # 0x173f51
movl $0xa6, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb0788
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xb07aa
movq 0x8(%rsp), %rdi
callq 0x25140
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rdi
callq 0xb6ac0
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movb $0x0, 0x29(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0x76220
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_merge
void gt_block_merge(GtBlock *b1, GtBlock *b2)
{
  unsigned int GT_UNUSED merged_size, i;
  gt_assert(b1 && b2);
  merged_size = gt_block_get_size(b1) + gt_block_get_size(b2);
  for (i=0;i<gt_array_size(b2->elements);i++)
  {
    GtElement *elem;
    elem = gt_element_ref(*(GtElement**) gt_array_get(b2->elements, i));
    gt_assert(elem);
    gt_array_add(b1->elements, elem);
  }
  gt_assert(gt_block_get_size(b1) == merged_size);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0xb07fe
cmpq $0x0, 0x28(%rsp)
jne 0xb0836
movq 0x1037d3(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xad857(%rip), %rsi     # 0x15e066
leaq 0xc37bd(%rip), %rdx     # 0x173fd3
leaq 0xc37bf(%rip), %rcx     # 0x173fdc
leaq 0xc372d(%rip), %r8      # 0x173f51
movl $0xb5, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb0838
movq 0x30(%rsp), %rdi
callq 0xb0970
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xb0970
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xb0918
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movl 0x20(%rsp), %eax
movl %eax, %esi
callq 0x75c80
movq (%rax), %rdi
callq 0xb6cc0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xb08ef
movq 0x10371a(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xad79e(%rip), %rsi     # 0x15e066
leaq 0xbbb6b(%rip), %rdx     # 0x16c43a
leaq 0xc3706(%rip), %rcx     # 0x173fdc
leaq 0xc3674(%rip), %r8      # 0x173f51
movl $0xbb, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb08f1
movq 0x30(%rsp), %rax
movq (%rax), %rdi
leaq 0x18(%rsp), %rsi
movl $0x8, %edx
callq 0x76220
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xb0868
jmp 0xb091a
movq 0x30(%rsp), %rdi
callq 0xb0970
movl 0x24(%rsp), %ecx
cmpq %rcx, %rax
je 0xb0965
movq 0x1036a4(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xad728(%rip), %rsi     # 0x15e066
leaq 0xc36a6(%rip), %rdx     # 0x173feb
leaq 0xc3690(%rip), %rcx     # 0x173fdc
leaq 0xc35fe(%rip), %r8      # 0x173f51
movl $0xbe, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb0967
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_has_only_one_fullsize_element
bool gt_block_has_only_one_fullsize_element(const GtBlock *block)
{
  bool ret = false;
  GtUword bsize;
  gt_assert(block);
  bsize = gt_array_size(block->elements);
  if (bsize == 1) {
    GtRange elem_range, block_range;
    gt_assert(*(GtElement**) gt_array_get(block->elements, 0) ==
              *(GtElement**) gt_array_get(block->elements, bsize-1));
    elem_range = gt_element_get_range(*(GtElement**)
                                             gt_array_get(block->elements, 0));
    block_range = gt_block_get_range(block);
    ret = (gt_range_compare(&block_range, &elem_range) == 0);
  }
  return ret;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movb $0x0, 0x5f(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0xb0d4e
movq 0x1032bb(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xad33f(%rip), %rsi     # 0x15e066
leaq 0xc4161(%rip), %rdx     # 0x174e8f
leaq 0xc3398(%rip), %rcx     # 0x1740cd
leaq 0xc3215(%rip), %r8      # 0x173f51
movl $0xf7, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb0d50
movq 0x60(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, 0x50(%rsp)
cmpq $0x1, 0x50(%rsp)
jne 0xb0e60
jmp 0xb0d70
movq 0x60(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rdi
movq 0x50(%rsp), %rsi
subq $0x1, %rsi
callq 0x75c80
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq (%rcx), %rax
je 0xb0de4
movq 0x103225(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xad2a9(%rip), %rsi     # 0x15e066
leaq 0xc3330(%rip), %rdx     # 0x1740f4
leaq 0xc3302(%rip), %rcx     # 0x1740cd
leaq 0xc317f(%rip), %r8      # 0x173f51
movl $0xfc, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb0de6
movq 0x60(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x75c80
movq (%rax), %rdi
callq 0xb6d20
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rdi
callq 0xb0380
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x93850
cmpl $0x0, %eax
sete %al
andb $0x1, %al
movb %al, 0x5f(%rsp)
movb 0x5f(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_sketch
int gt_block_sketch(GtBlock *block, GtCanvas *canvas, GtError *err)
{
  int had_err = 0;
  GtUword i;
  gt_assert(block && canvas && err);
  /* if resulting block was too short,
     do not traverse this feature tree further */
  had_err = gt_canvas_visit_block(canvas, block, err);
  if (had_err)
  {
    if (had_err == 1)  /* 'magic' value */
      return 0;
    else
      return had_err;
  } /* we have in any case returned if had_err was set */
  if (!block->sorted)
  {
    GtStyle *sty = gt_canvas_get_style(canvas);
    /* sort elements if they have changed since last sketch operation */
    gt_array_sort_with_data(block->elements, elemcmp, sty);
    block->sorted = true;
  }
  /* delegate sketch request to elements */
  for (i=0;i<gt_array_size(block->elements);i++) {
     GtElement *elem = *(GtElement**) gt_array_get(block->elements, i);
     had_err = gt_element_sketch(elem, canvas, err);
  }
  return had_err;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0xb13c3
cmpq $0x0, 0x30(%rsp)
je 0xb13c3
cmpq $0x0, 0x28(%rsp)
jne 0xb13fb
movq 0x102c0e(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xacc92(%rip), %rsi     # 0x15e066
leaq 0xc2e84(%rip), %rdx     # 0x17425f
leaq 0xc2e94(%rip), %rcx     # 0x174276
leaq 0xc2b68(%rip), %r8      # 0x173f51
movl $0x165, %r9d            # imm = 0x165
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb13fd
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x3ad00
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
je 0xb143d
cmpl $0x1, 0x24(%rsp)
jne 0xb1430
movl $0x0, 0x44(%rsp)
jmp 0xb14ee
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xb14ee
movq 0x38(%rsp), %rax
testb $0x1, 0x29(%rax)
jne 0xb1479
movq 0x30(%rsp), %rdi
callq 0x3aee0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x95(%rip), %rsi        # 0xb1500
callq 0x76740
movq 0x38(%rsp), %rax
movb $0x1, 0x29(%rax)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0xb14e6
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xb6e90
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xb1482
movl 0x24(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/block.c
// Function: gt_block_delete
void gt_block_delete(GtBlock *block)
{
  GtUword i;
  if (!block) return;
  if (block->reference_count) {
    block->reference_count--;
    return;
  }
  for (i=0;i<gt_array_size(block->elements);i++) {
    GtElement *elem = *(GtElement**) gt_array_get(block->elements, i);
    gt_element_delete(elem);
  }
  if (block->caption)
    gt_str_delete(block->caption);
  gt_array_delete(block->elements);
  if (block->top_level_feature)
    gt_genome_node_delete((GtGenomeNode*) block->top_level_feature);
  gt_free(block);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xb21c6
jmp 0xb22a0
movq 0x20(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0xb21e8
movq 0x20(%rsp), %rax
movq 0x40(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0xb22a0
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x76490
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xb2249
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x75c80
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xb74c0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xb21f1
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0xb2263
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1afc0
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x770a0
movq 0x20(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0xb228a
movq 0x20(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x26eb0
movq 0x20(%rsp), %rdi
leaq 0xc1cbb(%rip), %rsi     # 0x173f51
movl $0x1ec, %edx            # imm = 0x1EC
callq 0xdab0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/canvas_cairo.c
// Function: gt_canvas_cairo_visit_layout_pre
int gt_canvas_cairo_visit_layout_pre(GtCanvas *canvas,
                                     GtLayout *layout,
                                     GtError *err)
{
  double head_track_space = HEAD_TRACK_SPACE_DEFAULT;
  /* get displayed range for internal use */
  canvas->pvt->viewrange = gt_layout_get_range(layout);
  if (gt_canvas_draw_ruler(canvas, canvas->pvt->viewrange, err)) {
    return -1;
  }
  if (gt_style_get_num(canvas->pvt->sty, "format", "ruler_space",
                       &head_track_space, NULL,err) == GT_STYLE_QUERY_ERROR) {
    return -1;
  }
  canvas->pvt->y += HEADER_SPACE + head_track_space;
  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movsd 0xb684d(%rip), %xmm0    # 0x168b18
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x46320
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x38(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x3a570
cmpl $0x0, %eax
je 0xb233a
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xb23a1
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rdi
movq 0x28(%rsp), %r9
leaq 0xabe43(%rip), %rsi     # 0x15e196
leaq 0xb69bf(%rip), %rdx     # 0x168d19
leaq 0x20(%rsp), %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x49af0
cmpl $0x2, %eax
jne 0xb2378
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xb23a1
movsd 0xb67a8(%rip), %xmm0    # 0x168b28
addsd 0x20(%rsp), %xmm0
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/canvas_cairo.c
// Function: gt_canvas_cairo_visit_track_post
int gt_canvas_cairo_visit_track_post(GtCanvas *canvas, GT_UNUSED GtTrack *track,
                                     GtError *err)
{
  double vspace = TRACK_VSPACE_DEFAULT;
  gt_assert(canvas && track);
  /* put track spacer after track */
  if (gt_style_get_num(canvas->pvt->sty, "format", "track_vspace", &vspace,
                       NULL, err) == GT_STYLE_QUERY_ERROR) {
    return -1;
  }
  canvas->pvt->y += vspace;
  return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movsd 0xb61ed(%rip), %xmm0    # 0x168b18
movsd %xmm0, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xb2940
cmpq $0x0, 0x10(%rsp)
jne 0xb2978
movq 0x101691(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xab715(%rip), %rsi     # 0x15e066
leaq 0xb4da1(%rip), %rdx     # 0x1676f9
leaq 0xc1c1e(%rip), %rcx     # 0x17457d
leaq 0xc1b52(%rip), %r8      # 0x1744b8
movl $0xa1, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb297a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rdi
movq 0x8(%rsp), %r9
leaq 0xab803(%rip), %rsi     # 0x15e196
leaq 0xb6372(%rip), %rdx     # 0x168d0c
movq %rsp, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x49af0
cmpl $0x2, %eax
jne 0xb29b6
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xb29d6
movsd (%rsp), %xmm0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/canvas_cairo.c
// Function: gt_canvas_cairo_visit_line_post
int gt_canvas_cairo_visit_line_post(GtCanvas *canvas, GtLine *line,
                                    GtError *err)
{
  int had_err = 0;
  double lheight,
         bar_vspace = BAR_VSPACE_DEFAULT;
  gt_assert(canvas && line);
  had_err = gt_line_get_height(line, &lheight, canvas->pvt->sty, err);
  if (!had_err) {
    if (gt_style_get_num(canvas->pvt->sty,
                         "format", "bar_vspace",
                         &bar_vspace, NULL, err) == GT_STYLE_QUERY_ERROR) {
      return -1;
    }
    canvas->pvt->y += bar_vspace + lheight/2;
    if (canvas->pvt->bt)
      gt_bittab_delete(canvas->pvt->bt);
    canvas->pvt->bt = NULL;
  }
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movsd 0xb4b8d(%rip), %xmm0    # 0x167810
movsd %xmm0, (%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xb2c98
cmpq $0x0, 0x20(%rsp)
jne 0xb2cd0
movq 0x101339(%rip), %rax    # 0x1b3fd8
movq (%rax), %rdi
leaq 0xab3bd(%rip), %rsi     # 0x15e066
leaq 0xb4a8e(%rip), %rdx     # 0x16773e
leaq 0xc1906(%rip), %rcx     # 0x1745bd
leaq 0xc17fa(%rip), %r8      # 0x1744b8
movl $0xd9, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb2cd2
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rdx
movq 0x18(%rsp), %rcx
leaq 0x8(%rsp), %rsi
callq 0xb77f0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0xb2d9f
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x38(%rax), %rdi
movq 0x18(%rsp), %r9
leaq 0xab47b(%rip), %rsi     # 0x15e196
leaq 0xb7319(%rip), %rdx     # 0x16a03b
movq %rsp, %rcx
xorl %eax, %eax
movl %eax, %r8d
callq 0x49af0
cmpl $0x2, %eax
jne 0xb2d3e
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xb2da7
movsd (%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movsd 0xb55d7(%rip), %xmm2    # 0x168328
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x50(%rax)
je 0xb2d8e
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x50(%rax), %rdi
callq 0x7a420
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x50(%rax)
movl 0x14(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/color.c
// Function: gt_color_new
GtColor* gt_color_new(double red, double green, double blue, double alpha)
{
  GtColor *color = gt_malloc(sizeof *color);
  color->red = red;
  color->green = green;
  color->blue = blue;
  color->alpha = alpha;
  return color;
}

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movsd %xmm3, (%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xb6130
movq 0xfded9(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0xa7f5d(%rip), %rsi     # 0x15e066
leaq 0xb316b(%rip), %rdx     # 0x16927b
leaq 0xbe6d4(%rip), %rcx     # 0x1747eb
leaq 0xbe6b0(%rip), %r8      # 0x1747ce
movl $0x23, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xb6132
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x10(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movsd (%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/annotationsketch/coords.c
// Function: gt_coords_calc_generic_range
GtDrawingRange gt_coords_calc_generic_range(GtRange node_range,
                                            GtRange viewrange)
{
  GtDrawingRange converted_range;
  converted_range.clip = CLIPPED_NONE;
  node_range.end++;
  /* scale coordinates to target image width */
  if (node_range.start < viewrange.start )
    converted_range.clip = CLIPPED_LEFT;
  converted_range.start = gt_coords_convert_point(viewrange, node_range.start);

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

  return converted_range;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movl $0x2, 0x10(%rdi)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0xb6352
movq 0x8(%rsp), %rax
movl $0x1, 0x10(%rax)
movq 0x28(%rsp), %rdx
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb6290
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jbe 0xb639a
movq 0x8(%rsp), %rax
movl 0x10(%rax), %esi
xorl %ecx, %ecx
movl $0x3, %edx
cmpl $0x1, %esi
cmovel %edx, %ecx
movl %ecx, 0x10(%rax)
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb6290
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rcx)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)