LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_filter.c
// Function: gt_script_filter_new_generic
static GtScriptFilter* gt_script_filter_new_generic(const char *file,
                                                    bool unsafe,
                                                    GtError *err)
{
  GtScriptFilter *script_filter;
  gt_assert(file);
  script_filter = gt_malloc(sizeof (GtScriptFilter));
  script_filter->filename = gt_str_new_cstr(file);
  script_filter->L = luaL_newstate();
  script_filter->reference_count = 0;
  if (!script_filter->L) {
    gt_error_set(err, "out of memory (cannot create new Lua state)");
    gt_free(script_filter);
    return NULL;
  }
  script_filter_luaL_opencustomlibs(script_filter->L,
                                     script_filter_luasecurelibs);
  if (unsafe)
    script_filter_luaL_opencustomlibs(script_filter->L,
                                      script_filter_luainsecurelibs);
  if (luaL_loadfile(script_filter->L, file) ||
                               lua_pcall(script_filter->L, 0, 0, 0)) {
    gt_error_set(err, "cannot run file: %s",
                 lua_tostring(script_filter->L, -1));
    lua_pop(script_filter->L, 1);
    lua_close(script_filter->L);
    gt_str_delete(script_filter->filename);
    gt_free(script_filter);
    return NULL;
  }
  return script_filter;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x114f3b
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x21d6cc(%rip), %rsi    # 0x33251f
pushq $0x18
popq %rdi
pushq $0x46
popq %rdx
callq 0x93160
movq %rax, %rbx
movq %r15, %rdi
callq 0xacbd1
movq %rax, 0x8(%rbx)
callq 0x1df5e2
movq %rax, (%rbx)
andq $0x0, 0x10(%rbx)
testq %rax, %rax
je 0x114f08
leaq 0x31dfa6(%rip), %rsi    # 0x432e30
movq %rax, %rdi
callq 0x11508a
testb %bpl, %bpl
je 0x114ea6
movq (%rbx), %rdi
leaq 0x31dfef(%rip), %rsi    # 0x432e90
callq 0x11508a
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x1df308
testl %eax, %eax
jne 0x114ec7
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1dcedd
testl %eax, %eax
je 0x114f2d
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x1dbb73
leaq 0x211e60(%rip), %rsi    # 0x326d3b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x89dbb
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x1db3d2
movq (%rbx), %rdi
callq 0x1de4cb
movq 0x8(%rbx), %rdi
callq 0xae103
pushq $0x5b
jmp 0x114f1b
leaq 0x20d462(%rip), %rsi    # 0x322371
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $0x4c
popq %rdx
leaq 0x21d5fc(%rip), %rsi    # 0x33251f
movq %rbx, %rdi
callq 0x936f9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x323026(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1d00c7(%rip), %rsi    # 0x2e5013
leaq 0x1d4959(%rip), %rdx    # 0x2e98ac
leaq 0x21d773(%rip), %rcx    # 0x3326cd
leaq 0x21d5be(%rip), %r8     # 0x33251f
pushq $0x45
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_filter.c
// Function: gt_script_filter_new_from_string
GtScriptFilter *gt_script_filter_new_from_string(const char *script_string,
                                                 GtError *err)
{
  GtScriptFilter *script_filter;
  gt_assert(script_string);
  script_filter = gt_malloc(sizeof (GtScriptFilter));
  script_filter->filename = NULL;
  script_filter->L = luaL_newstate();
  script_filter->reference_count = 0;
  if (!script_filter->L) {
    gt_error_set(err, "out of memory (cannot create new Lua state)");
    gt_free(script_filter);
    return NULL;
  }
  script_filter_luaL_opencustomlibs(script_filter->L,
                                     script_filter_luasecurelibs);
  if (luaL_loadstring(script_filter->L, script_string) ||
                               lua_pcall(script_filter->L, 0, 0, 0)) {
    gt_error_set(err, "cannot run file: %s",
                 lua_tostring(script_filter->L, -1));
    lua_pop(script_filter->L, 1);
    lua_close(script_filter->L);
    gt_free(script_filter);
    return NULL;
  }
  return script_filter;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x115054
movq %rsi, %r14
movq %rdi, %r15
leaq 0x21d589(%rip), %rsi    # 0x33251f
pushq $0x18
popq %rdi
pushq $0x70
popq %rdx
callq 0x93160
movq %rax, %rbx
andq $0x0, 0x8(%rax)
callq 0x1df5e2
movq %rax, (%rbx)
andq $0x0, 0x10(%rbx)
testq %rax, %rax
je 0x115026
leaq 0x31de6e(%rip), %rsi    # 0x432e30
movq %rax, %rdi
callq 0x11508a
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x1df5b8
testl %eax, %eax
jne 0x114feb
movq (%rbx), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1dcedd
testl %eax, %eax
je 0x11504b
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x1dbb73
leaq 0x211d3c(%rip), %rsi    # 0x326d3b
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x89dbb
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x1db3d2
movq (%rbx), %rdi
callq 0x1de4cb
movl $0x81, %edx
jmp 0x11503a
leaq 0x20d344(%rip), %rsi    # 0x322371
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $0x76
popq %rdx
leaq 0x21d4de(%rip), %rsi    # 0x33251f
movq %rbx, %rdi
callq 0x936f9
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x322f0d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cffae(%rip), %rsi    # 0x2e5013
leaq 0x21d484(%rip), %rdx    # 0x3324f0
leaq 0x21d48b(%rip), %rcx    # 0x3324fe
leaq 0x21d4a5(%rip), %r8     # 0x33251f
pushq $0x6f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_filter.c
// Function: script_filter_luaL_opencustomlibs
static void script_filter_luaL_opencustomlibs(lua_State *L,
                                              const luaL_Reg *lib)
{
  for (; lib->func; lib++) {
    lua_pushcfunction(L, lib->func);
    lua_pushstring(L, lib->name);
    lua_call(L, 1, 0);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rbx
pushq $0x1
popq %rbp
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x1150cb
movq %r14, %rdi
xorl %edx, %edx
callq 0x1dc3ec
movq -0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1dc009
movq %r14, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x1dce3a
addq $0x10, %rbx
jmp 0x11509b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_filter.c
// Function: gt_script_filter_run
int gt_script_filter_run(GtScriptFilter *sf, GtFeatureNode *gf,
                         bool *select_node, GtError *err)
{
  int had_err = 0;
#ifndef NDEBUG
  int stack_size;
#endif
  GtGenomeNode *gn_lua;

#ifndef NDEBUG
  stack_size = lua_gettop(sf->L);
#endif

  if (!had_err) {
    lua_getglobal(sf->L, "filter");
    if (lua_isnil(sf->L, -1)) {
      gt_error_set(err, "function 'filter' is not defined");
      had_err = -1;
      lua_pop(sf->L, 1);
    }
  }

  if (!had_err) {
    gn_lua = gt_genome_node_ref((GtGenomeNode*) gf);
    gt_lua_genome_node_push(sf->L, gn_lua);

    if (lua_pcall(sf->L, 1, 1, 0) != 0) {
      gt_error_set(err, "error running function 'filter': %s",
                   lua_tostring(sf->L, -1));
      lua_pop(sf->L, 1);
      had_err = -1;
    }
  }

  if (!had_err && !lua_isboolean(sf->L, -1)) {
    gt_error_set(err, "function 'filter' must return boolean");
    lua_pop(sf->L, 1);
    had_err = -1;
  }

  if (!had_err) {
    *select_node = lua_toboolean(sf->L, -1);
    lua_pop(sf->L, 1);
  }
  gt_assert(lua_gettop(sf->L) == stack_size);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1db3c5
movl %eax, %ebp
movq (%rbx), %rdi
leaq 0x1e31f2(%rip), %rdx    # 0x2f8765
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
callq 0x1dc63b
movq (%rbx), %rdi
pushq $-0x1
popq %r14
movl %r14d, %esi
callq 0x1db731
testl %eax, %eax
je 0x1155d9
movq %r13, %rdi
callq 0xdccf8
movq (%rbx), %rdi
movq %rax, %rsi
callq 0x12f524
movq (%rbx), %rdi
pushq $0x1
popq %rdx
movl %edx, %esi
xorl %ecx, %ecx
callq 0x1dcedd
movq (%rbx), %rdi
testl %eax, %eax
je 0x1155e2
movl %r14d, %esi
xorl %edx, %edx
callq 0x1dbb73
leaq 0x21d084(%rip), %rsi    # 0x33264e
movq %r15, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x89dbb
jmp 0x11561b
leaq 0x21d04d(%rip), %rsi    # 0x33262d
jmp 0x115611
pushq $-0x1
popq %r14
movl %r14d, %esi
callq 0x1db731
cmpl $0x1, %eax
jne 0x11560a
movq (%rbx), %rdi
pushq $-0x1
popq %rsi
callq 0x1dbb4f
testl %eax, %eax
setne (%r12)
xorl %r14d, %r14d
jmp 0x11561b
leaq 0x21d061(%rip), %rsi    # 0x332672
movq %r15, %rdi
xorl %eax, %eax
callq 0x89dbb
movq (%rbx), %rdi
pushq $-0x2
popq %rsi
callq 0x1db3d2
movq (%rbx), %rdi
callq 0x1db3c5
cmpl %ebp, %eax
jne 0x115644
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x32291d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cf9be(%rip), %rsi    # 0x2e5013
leaq 0x21d03c(%rip), %rdx    # 0x332698
leaq 0x21d055(%rip), %rcx    # 0x3326b8
leaq 0x21ceb5(%rip), %r8     # 0x33251f
movl $0x13a, %r9d            # imm = 0x13A
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/script_filter.c
// Function: gt_script_filter_delete
void gt_script_filter_delete(GtScriptFilter *script_filter)
{
  if (!script_filter) return;
  if (script_filter->reference_count) {
    script_filter->reference_count--;
    return;
  }
  gt_str_delete(script_filter->filename);
  lua_close(script_filter->L);
  gt_free(script_filter);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1156a2
movq %rdi, %rbx
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1156a4
decq %rax
movq %rax, 0x10(%rbx)
popq %rbx
retq
movq 0x8(%rbx), %rdi
callq 0xae103
movq (%rbx), %rdi
callq 0x1de4cb
leaq 0x21ce63(%rip), %rsi    # 0x33251f
movq %rbx, %rdi
movl $0x14f, %edx            # imm = 0x14F
popq %rbx
jmp 0x936f9
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_stream.c
// Function: gt_select_stream_class
const GtNodeStreamClass* gt_select_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSelectStream),
                                   select_stream_free,
                                   select_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x32812e(%rip)    # 0x43d808
jne 0x1156f9
leaq 0x24(%rip), %rsi        # 0x115707
leaq 0x47(%rip), %rdx        # 0x115731
pushq $0x20
popq %rdi
callq 0x102838
movq %rax, 0x32810f(%rip)    # 0x43d808
callq 0x69ede
movq 0x328103(%rip), %rax    # 0x43d808
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_stream.c
// Function: select_stream_next
static int select_stream_next(GtNodeStream *ns, GtGenomeNode **gn, GtError *err)
{
  GtSelectStream *fs;
  int had_err;
  gt_error_check(err);
  fs = gt_select_stream_cast(ns);

  /* we still have nodes in the buffer */
  if (gt_select_visitor_node_buffer_size(fs->select_visitor)) {
    /* return one of them */
    *gn = gt_select_visitor_get_node(fs->select_visitor);
    return 0;
  }

  /* no nodes in the buffer -> get new nodes */
  while (!(had_err = gt_node_stream_next(fs->in_stream, gn, err)) && *gn) {
    gt_assert(*gn && !had_err);
    had_err = gt_genome_node_accept(*gn, fs->select_visitor, err);
    if (had_err) {
      /* we own the node -> delete it */
      gt_genome_node_delete(*gn);
      *gn = NULL;
      break;
    }
    if (gt_select_visitor_node_buffer_size(fs->select_visitor)) {
      *gn = gt_select_visitor_get_node(fs->select_visitor);
      return 0;
    }
  }

  /* either we have an error or no new node */
  gt_assert(had_err || !*gn);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x115756
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1157d9
callq 0x1156cc
movq %rax, %rdi
movq %r15, %rsi
callq 0x102c81
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x116695
testq %rax, %rax
jne 0x1157a8
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x102a22
testl %eax, %eax
jne 0x1157c3
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1157c7
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0xdd39c
testl %eax, %eax
jne 0x1157cb
movq 0x18(%r15), %rdi
jmp 0x11576d
movq 0x18(%r15), %rdi
callq 0x1166b3
xorl %ebp, %ebp
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
jmp 0x1157b6
xorl %ebp, %ebp
jmp 0x1157b6
movl %eax, %ebp
movq (%rbx), %rdi
callq 0xde013
xorl %eax, %eax
jmp 0x1157b3
movq 0x322788(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cf829(%rip), %rsi    # 0x2e5013
leaq 0x1cf9ce(%rip), %rdx    # 0x2e51bf
leaq 0x22116d(%rip), %rcx    # 0x336965
leaq 0x21cf90(%rip), %r8     # 0x33278f
pushq $0x2a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_stream.c
// Function: gt_select_stream_new
GtNodeStream* gt_select_stream_new(GtNodeStream *in_stream, GtStr *seqid,
                                   GtStr *source, const GtRange *contain_range,
                                   const GtRange *overlap_range,
                                   GtStrand strand, GtStrand targetstrand,
                                   bool has_CDS, GtUword max_gene_length,
                                   GtUword max_gene_num,
                                   double min_gene_score, double max_gene_score,
                                   double min_average_splice_site_prob,
                                   GtUword feature_num,
                                   GtStrArray *select_files,
                                   GtStr *select_logic, GtError *err)
{
  GtNodeStream *ns = gt_node_stream_create(gt_select_stream_class(),
                                          gt_node_stream_is_sorted(in_stream));
  GtSelectStream *select_stream = gt_select_stream_cast(ns);
  gt_assert(in_stream);
  select_stream->in_stream = gt_node_stream_ref(in_stream);
  select_stream->select_visitor =
    gt_select_visitor_new(seqid, source, contain_range, overlap_range, strand,
                          targetstrand, has_CDS, max_gene_length, max_gene_num,
                          min_gene_score, max_gene_score,
                          min_average_splice_site_prob, feature_num,
                          select_files, select_logic, err);
  if  (!select_stream->select_visitor) {
    gt_node_stream_delete(ns);
    return NULL;
  }
  return ns;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm2, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movl %r9d, 0xc(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0x1156cc
movq %rax, %rbx
movq %r14, %rdi
callq 0x102c3d
movzbl %al, %esi
movq %rbx, %rdi
callq 0x10289f
movq %rax, %rbx
callq 0x1156cc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
testq %r14, %r14
je 0x11591f
movq %rax, %rbp
movb 0x78(%rsp), %r15b
movq %r14, %rdi
callq 0x102934
movq %rax, 0x10(%rbp)
subq $0x8, %rsp
movzbl %r15b, %eax
movq %r13, %rdi
movq %r12, %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
movl 0x14(%rsp), %r8d
movl 0x78(%rsp), %r9d
movsd 0x28(%rsp), %xmm0
movsd 0x30(%rsp), %xmm1
movsd 0x38(%rsp), %xmm2
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq 0xb0(%rsp)
pushq %rax
callq 0x116405
addq $0x40, %rsp
movq %rax, 0x18(%rbp)
testq %rax, %rax
jne 0x11590d
movq %rbx, %rdi
callq 0x10297b
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x322642(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cf6e3(%rip), %rsi    # 0x2e5013
leaq 0x1d9a5c(%rip), %rdx    # 0x2ef393
leaq 0x21ce3c(%rip), %rcx    # 0x33277a
leaq 0x21ce4a(%rip), %r8     # 0x33278f
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_stream.c
// Function: gt_select_stream_set_drophandler
void gt_select_stream_set_drophandler(GtSelectStream *fs,
                                      GtSelectNodeFunc fp,
                                      void *data)
{
  gt_assert(fs && fp != NULL);
  GtSelectVisitor *fv;
  fv = gt_node_visitor_cast(gt_select_visitor_class(), fs->select_visitor);
  gt_select_visitor_set_drophandler(fv, fp, data);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1159c3
movq %rsi, %r14
testq %rsi, %rsi
je 0x1159c3
movq %rdx, %rbx
movq %rdi, %r15
callq 0x1159fc
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x102dfe
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1166d1
movq 0x32259e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cf63f(%rip), %rsi    # 0x2e5013
leaq 0x21cdd1(%rip), %rdx    # 0x3327ac
leaq 0x21cddb(%rip), %rcx    # 0x3327bd
leaq 0x21cda6(%rip), %r8     # 0x33278f
movl $0x87, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_visitor.c
// Function: gt_select_visitor_class
const GtNodeVisitorClass* gt_select_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSelectVisitor),
                                    select_visitor_free,
                                    select_visitor_comment_node,
                                    select_visitor_feature_node,
                                    select_visitor_region_node,
                                    select_visitor_sequence_node,
                                    select_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc, select_visitor_meta_node);
  }
  return nvc;
}

// Assembly:
movq 0x327e0d(%rip), %rax    # 0x43d810
testq %rax, %rax
je 0x115a09
retq
pushq %rax
leaq 0x904(%rip), %rax       # 0x116315
movq %rax, (%rsp)
leaq 0x48(%rip), %rsi        # 0x115a64
leaq 0xca(%rip), %rdx        # 0x115aed
leaq 0x13a(%rip), %rcx       # 0x115b64
leaq 0x6e2(%rip), %r8        # 0x116113
leaq 0x80f(%rip), %r9        # 0x116247
movl $0xc8, %edi
callq 0x102cd0
movq %rax, 0x327dc7(%rip)    # 0x43d810
leaq 0x93e(%rip), %rsi       # 0x11638e
movq %rax, %rdi
callq 0x102d5f
movq 0x327db1(%rip), %rax    # 0x43d810
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_free
static void select_visitor_free(GtNodeVisitor *nv)
{
  int i;
  GtSelectVisitor *select_visitor = select_visitor_cast(nv);
  gt_str_delete(select_visitor->source);
  gt_str_delete(select_visitor->seqid);
  if (gt_array_size(select_visitor->script_filters) > 0) {
    for (i = 0; i < gt_array_size(select_visitor->script_filters); i++) {
      GtScriptFilter *todelete =
            *(GtScriptFilter**) gt_array_get(select_visitor->script_filters, i);
      gt_script_filter_delete(todelete);
    }
  }
  gt_array_delete(select_visitor->script_filters);
  gt_queue_delete(select_visitor->node_buffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1159fc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
movq %rax, %rbx
movq 0x20(%rax), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0xb0(%rbx), %rdi
callq 0x586a4
testq %rax, %rax
je 0x115ad1
xorl %r14d, %r14d
movq 0xb0(%rbx), %rdi
callq 0x586a4
cmpq %r14, %rax
jbe 0x115ad1
movq 0xb0(%rbx), %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0x115689
incq %r14
jmp 0x115aa4
movq 0xb0(%rbx), %rdi
callq 0x58eb9
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9e9dd
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_comment_node
static int select_visitor_comment_node(GtNodeVisitor *nv, GtCommentNode *c,
                                       GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  gt_queue_add(select_visitor->node_buffer, c);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x115b08
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x115b2e
callq 0x1159fc
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x9e2d1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x322433(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cf4d4(%rip), %rsi    # 0x2e5013
leaq 0x1cf679(%rip), %rdx    # 0x2e51bf
leaq 0x21cd29(%rip), %rcx    # 0x332876
leaq 0x21ccd1(%rip), %r8     # 0x332825
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_region_node
static int select_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                      GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  if (!gt_str_length(select_visitor->seqid) || /* no seqid was specified */
      !gt_str_cmp(select_visitor->seqid,       /* or seqids are equal */
               gt_genome_node_get_seqid((GtGenomeNode*) rn))) {
    if (select_visitor->contain_range.start != GT_UNDEF_UWORD) {
      GtRange range = gt_genome_node_get_range((GtGenomeNode*) rn);
      if (gt_range_overlap(&range, &select_visitor->contain_range)) {
        /* an overlapping contain range was defined -> update range  */
        range.start = GT_MAX(range.start, select_visitor->contain_range.start);
        range.end = GT_MIN(range.end, select_visitor->contain_range.end);
        gt_genome_node_set_range((GtGenomeNode*) rn, &range);
        gt_queue_add(select_visitor->node_buffer, rn);
      }
      else {
        /* contain range does not overlap with <rn> range -> handle <rn> */
        select_visitor->drophandler((GtGenomeNode*) rn, select_visitor->data,
                                    err);
        gt_genome_node_delete((GtGenomeNode*) rn);
      }
    }
    else
      gt_queue_add(select_visitor->node_buffer, rn);
  }
  else {
    select_visitor->drophandler((GtGenomeNode*) rn, select_visitor->data, err);
    gt_genome_node_delete((GtGenomeNode*) rn);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x11613c
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x11620f
callq 0x1159fc
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0xad289
testq %rax, %rax
je 0x116178
movq 0x18(%r15), %r12
movq %rbx, %rdi
callq 0xdd14a
movq %r12, %rdi
movq %rax, %rsi
callq 0xad39b
testl %eax, %eax
jne 0x1161e5
cmpq $-0x1, 0x28(%r15)
je 0x1161d7
movq %r15, %r12
addq $0x28, %r12
movq %rbx, %rdi
callq 0xdd1f4
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r12, %rsi
callq 0xa3234
testb %al, %al
je 0x1161e5
movq 0x28(%r15), %rax
leaq 0x8(%rsp), %rsi
movq (%rsi), %rcx
cmpq %rax, %rcx
cmovaq %rcx, %rax
movq 0x8(%rsi), %rcx
movq %rax, (%rsi)
movq 0x30(%r15), %rax
cmpq %rax, %rcx
cmovbq %rcx, %rax
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0xdd2bb
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x9e2d1
jmp 0x116201
movq 0xc0(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0xb8(%r15)
movq %rbx, %rdi
callq 0xde013
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x321d52(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cedf3(%rip), %rsi    # 0x2e5013
leaq 0x1cef98(%rip), %rdx    # 0x2e51bf
leaq 0x21c6d1(%rip), %rcx    # 0x3328ff
leaq 0x21c5f0(%rip), %r8     # 0x332825
movl $0x128, %r9d            # imm = 0x128
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_sequence_node
static int select_visitor_sequence_node(GtNodeVisitor *nv, GtSequenceNode *sn,
                                        GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  if (!gt_str_length(select_visitor->seqid) || /* no seqid was specified */
      !gt_str_cmp(select_visitor->seqid,       /* or seqids are equal */
                  gt_genome_node_get_seqid((GtGenomeNode*) sn))) {
    gt_queue_add(select_visitor->node_buffer, sn);
  }
  else {
    select_visitor->drophandler((GtGenomeNode*) sn, select_visitor->data, err);
    gt_genome_node_delete((GtGenomeNode*) sn);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x116269
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1162dd
callq 0x1159fc
movq %rax, %rdi
movq %r15, %rsi
callq 0x102dfe
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0xad289
testq %rax, %rax
je 0x1162c3
movq 0x18(%r15), %r12
movq %rbx, %rdi
callq 0xdd14a
movq %r12, %rdi
movq %rax, %rsi
callq 0xad39b
testl %eax, %eax
je 0x1162c3
movq 0xc0(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0xb8(%r15)
movq %rbx, %rdi
callq 0xde013
jmp 0x1162cf
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x9e2d1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x321c84(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ced25(%rip), %rsi    # 0x2e5013
leaq 0x1ceeca(%rip), %rdx    # 0x2e51bf
leaq 0x21c61e(%rip), %rcx    # 0x33291a
leaq 0x21c522(%rip), %r8     # 0x332825
movl $0x14b, %r9d            # imm = 0x14B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_eof_node
static int select_visitor_eof_node(GtNodeVisitor *nv, GtEOFNode *eofn,
                                   GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  gt_queue_add(select_visitor->node_buffer, eofn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x116330
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x116356
callq 0x1159fc
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x9e2d1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x321c0b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cecac(%rip), %rsi    # 0x2e5013
leaq 0x1cee51(%rip), %rdx    # 0x2e51bf
leaq 0x21c5c2(%rip), %rcx    # 0x332937
leaq 0x21c4a9(%rip), %r8     # 0x332825
movl $0x15d, %r9d            # imm = 0x15D
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_meta_node
static int select_visitor_meta_node(GtNodeVisitor *nv, GtMetaNode *mn,
                                    GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  gt_queue_add(select_visitor->node_buffer, mn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x1163a9
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1163cf
callq 0x1159fc
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x9e2d1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x321b92(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cec33(%rip), %rsi    # 0x2e5013
leaq 0x1cedd8(%rip), %rdx    # 0x2e51bf
leaq 0x21c561(%rip), %rcx    # 0x33294f
leaq 0x21c430(%rip), %r8     # 0x332825
pushq $0x62
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqid2file.c
// Function: gt_seqid2file_info_new
GtSeqid2FileInfo* gt_seqid2file_info_new(void)
{
  GtSeqid2FileInfo *s2fi = gt_calloc(1, sizeof *s2fi);
  s2fi->seqfiles = gt_str_array_new();
  s2fi->seqfile = gt_str_new();
  s2fi->encseq = gt_str_new();
  s2fi->region_mapping = gt_str_new();
  return s2fi;
}

// Assembly:
pushq %rbx
leaq 0x21c23c(%rip), %rdx    # 0x332968
pushq $0x1
popq %rdi
pushq $0x28
popq %rsi
pushq $0x23
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xae154
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqid2file.c
// Function: gt_seqid2file_info_delete
void gt_seqid2file_info_delete(GtSeqid2FileInfo *s2fi)
{
  if (!s2fi) return;
  gt_str_delete(s2fi->region_mapping);
  gt_str_delete(s2fi->seqfile);
  gt_str_delete(s2fi->encseq);
  gt_str_array_delete(s2fi->seqfiles);
  gt_free(s2fi);
}

// Assembly:
testq %rdi, %rdi
je 0x1167a4
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq (%rbx), %rdi
callq 0xae662
leaq 0x21c1d0(%rip), %rsi    # 0x332968
pushq $0x32
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqid2file.c
// Function: seqid2file_check
static int seqid2file_check(void *data, GT_UNUSED GtError *err)
{
  GtSeqid2FileInfo *info = (GtSeqid2FileInfo*) data;
  gt_error_check(err);
  gt_assert(info);
  if (gt_str_length(info->seqfile)) {
    gt_assert(!gt_str_array_size(info->seqfiles));
    gt_str_array_add(info->seqfiles, info->seqfile);
  }
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x116a54
movq %rsi, %rdi
callq 0x89eb7
testb %al, %al
jne 0x116aae
testq %rbx, %rbx
je 0x116a84
movq 0x10(%rbx), %rdi
callq 0xad289
testq %rax, %rax
je 0x116a80
movq (%rbx), %rdi
callq 0xae61c
testq %rax, %rax
jne 0x116ad8
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0xae31d
xorl %eax, %eax
popq %rbx
retq
movq 0x3214dd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ce57e(%rip), %rsi    # 0x2e5013
leaq 0x21d03a(%rip), %rdx    # 0x333ad6
leaq 0x21c285(%rip), %rcx    # 0x332d28
leaq 0x21bebe(%rip), %r8     # 0x332968
pushq $0x39
jmp 0x116b00
movq 0x3214b3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ce554(%rip), %rsi    # 0x2e5013
leaq 0x1ce6f9(%rip), %rdx    # 0x2e51bf
leaq 0x21c25b(%rip), %rcx    # 0x332d28
leaq 0x21be94(%rip), %r8     # 0x332968
pushq $0x38
jmp 0x116b00
movq 0x321489(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ce52a(%rip), %rsi    # 0x2e5013
leaq 0x21c249(%rip), %rdx    # 0x332d39
leaq 0x21c231(%rip), %rcx    # 0x332d28
leaq 0x21be6a(%rip), %r8     # 0x332968
pushq $0x3b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqpos_classifier.c
// Function: gt_seqpos_classifier_new
GtSeqposClassifier *gt_seqpos_classifier_new(const char *filename,
    const char *feature_type)
{
  GtSeqposClassifier *seqpos_classifier;
  seqpos_classifier = gt_malloc(sizeof (GtSeqposClassifier));
  seqpos_classifier->annotation_stream = gt_gff3_in_stream_new_sorted(filename);
  seqpos_classifier->fn = NULL;
  seqpos_classifier->fni = NULL;
  seqpos_classifier->gn = NULL;
  seqpos_classifier->nof_specified_ft_found = 0;
  seqpos_classifier->specified_ft = feature_type;
  return seqpos_classifier;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x21b83b(%rip), %rsi    # 0x332f6d
pushq $0x40
popq %rdi
pushq $0x2c
popq %rdx
callq 0x93160
movq %rax, %r15
movq %r14, %rdi
callq 0xdef57
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x18(%r15)
movq %rbx, 0x38(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/seqpos_classifier.c
// Function: gt_seqpos_classifier_delete
void gt_seqpos_classifier_delete(GtSeqposClassifier *seqpos_classifier)
{
  if (seqpos_classifier != NULL)
  {
    if (seqpos_classifier->fni != NULL)
    {
      gt_feature_node_iterator_delete(seqpos_classifier->fni);
    }
    if (seqpos_classifier->gn != NULL)
    {
      gt_genome_node_delete(seqpos_classifier->gn);
    }
    gt_node_stream_delete(seqpos_classifier->annotation_stream);
    gt_free(seqpos_classifier);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x117bd8
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x117bad
callq 0xdc9f1
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x117bbb
callq 0xde013
movq (%rbx), %rdi
callq 0x10297b
leaq 0x21b3a3(%rip), %rsi    # 0x332f6d
movq %rbx, %rdi
movl $0xea, %edx
popq %rbx
jmp 0x936f9
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_add_stream.c
// Function: gt_sequence_node_add_stream_class
const GtNodeStreamClass* gt_sequence_node_add_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSequenceNodeAddStream),
                                   sequence_node_add_stream_free,
                                   sequence_node_add_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x325946(%rip)    # 0x43d820
jne 0x117ef9
leaq 0x24(%rip), %rsi        # 0x117f07
leaq 0x59(%rip), %rdx        # 0x117f43
pushq $0x40
popq %rdi
callq 0x102838
movq %rax, 0x325927(%rip)    # 0x43d820
callq 0x69ede
movq 0x32591b(%rip), %rax    # 0x43d820
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_add_stream.c
// Function: sequence_node_add_stream_free
static void sequence_node_add_stream_free(GtNodeStream *ns)
{
  GtSequenceNodeAddStream *fs = gt_sequence_node_add_stream_cast(ns);
  gt_node_visitor_delete(fs->collect_vis);
  gt_cstr_table_delete(fs->seqid_table);
  gt_str_array_delete(fs->seqids);
  gt_node_stream_delete(fs->in_stream);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x117ecc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x10327a
movq 0x20(%rbx), %rdi
callq 0x6cf6b
movq 0x28(%rbx), %rdi
callq 0xae662
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x10297b
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_add_stream.c
// Function: gt_sequence_node_add_stream_new
GtNodeStream* gt_sequence_node_add_stream_new(GtNodeStream *in_stream,
                                              GtRegionMapping *rm,
                                              GT_UNUSED GtError *err)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sequence_node_add_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtSequenceNodeAddStream *s = gt_sequence_node_add_stream_cast(ns);
  gt_assert(in_stream);
  s->rm = rm;
  s->in_stream = gt_node_stream_ref(in_stream);
  s->seqid_table = gt_cstr_table_new();
  s->seqids = NULL;
  s->cur_seqid = 0;
  s->collect_vis = gt_collect_ids_visitor_new(s->seqid_table);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x117ecc
movq %rax, %rbx
movq %r14, %rdi
callq 0x102c3d
movzbl %al, %esi
movq %rbx, %rdi
callq 0x10289f
movq %rax, %rbx
callq 0x117ecc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
testq %r14, %r14
je 0x1181b8
movq %rax, %r12
movq %r15, 0x30(%rax)
movq %r14, %rdi
callq 0x102934
movq %rax, 0x10(%r12)
callq 0x6ca6c
movq %rax, 0x20(%r12)
andq $0x0, 0x28(%r12)
andq $0x0, 0x38(%r12)
movq %rax, %rdi
callq 0xbeebc
movq %rax, 0x18(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x31fda9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cce4a(%rip), %rsi    # 0x2e5013
leaq 0x1d71c3(%rip), %rdx    # 0x2ef393
leaq 0x21b013(%rip), %rcx    # 0x3331ea
leaq 0x21b02c(%rip), %r8     # 0x33320a
pushq $0x7e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_out_stream.c
// Function: gt_sequence_node_out_stream_class
const GtNodeStreamClass* gt_sequence_node_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSequenceNodeOutStream),
                                   sequence_node_out_stream_free,
                                   sequence_node_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x32562a(%rip)    # 0x43d828
jne 0x11821d
leaq 0x24(%rip), %rsi        # 0x11822b
leaq 0x47(%rip), %rdx        # 0x118255
pushq $0x20
popq %rdi
callq 0x102838
movq %rax, 0x32560b(%rip)    # 0x43d828
callq 0x69ede
movq 0x3255ff(%rip), %rax    # 0x43d828
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_out_stream.c
// Function: sequence_node_out_stream_next
static int sequence_node_out_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                         GtError *err)
{
  GtSequenceNodeOutStream *fs;
  int had_err;
  gt_error_check(err);
  fs = gt_sequence_node_out_stream_cast(ns);

  /* we still have nodes in the buffer */
  if (gt_sequence_node_out_visitor_node_buffer_size(
                                               fs->sequence_node_out_visitor)) {
    /* return one of them */
    *gn = gt_sequence_node_out_visitor_get_node(fs->sequence_node_out_visitor);
    return 0;
  }

  /* no nodes in the buffer -> get new nodes */
  while (!(had_err = gt_node_stream_next(fs->in_stream, gn, err)) && *gn) {
    gt_assert(*gn && !had_err);
    had_err = gt_genome_node_accept(*gn, fs->sequence_node_out_visitor, err);
    if (had_err) {
      /* we own the node -> delete it */
      gt_genome_node_delete(*gn);
      *gn = NULL;
      break;
    }
    if (gt_sequence_node_out_visitor_node_buffer_size(
                                               fs->sequence_node_out_visitor)) {
     *gn = gt_sequence_node_out_visitor_get_node(fs->sequence_node_out_visitor);
     return 0;
    }
  }

  /* either we have an error or no new node */
  gt_assert(had_err || !*gn);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x11827a
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1182fd
callq 0x1181f0
movq %rax, %rdi
movq %r15, %rsi
callq 0x102c81
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x118978
testq %rax, %rax
jne 0x1182cc
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x102a22
testl %eax, %eax
jne 0x1182e7
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1182eb
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0xdd39c
testl %eax, %eax
jne 0x1182ef
movq 0x18(%r15), %rdi
jmp 0x118291
movq 0x18(%r15), %rdi
callq 0x118996
xorl %ebp, %ebp
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
jmp 0x1182da
xorl %ebp, %ebp
jmp 0x1182da
movl %eax, %ebp
movq (%rbx), %rdi
callq 0xde013
xorl %eax, %eax
jmp 0x1182d7
movq 0x31fc64(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ccd05(%rip), %rsi    # 0x2e5013
leaq 0x1cceaa(%rip), %rdx    # 0x2e51bf
leaq 0x21af86(%rip), %rcx    # 0x3332a2
leaq 0x21af57(%rip), %r8     # 0x33327a
pushq $0x2c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_out_stream.c
// Function: gt_sequence_node_out_stream_new
GtNodeStream* gt_sequence_node_out_stream_new(GtNodeStream *in_stream,
                                              GtFile *outfile,
                                              GT_UNUSED GtError *err)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sequence_node_out_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtSequenceNodeOutStream *s = gt_sequence_node_out_stream_cast(ns);
  gt_assert(in_stream);
  s->in_stream = gt_node_stream_ref(in_stream);
  s->sequence_node_out_visitor =
    gt_sequence_node_out_visitor_new(outfile);
  if  (!s->sequence_node_out_visitor) {
    gt_node_stream_delete(ns);
    return NULL;
  }
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x1181f0
movq %rax, %r14
movq %r15, %rdi
callq 0x102c3d
movzbl %al, %esi
movq %r14, %rdi
callq 0x10289f
movq %rax, %r14
callq 0x1181f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x102c81
testq %r15, %r15
je 0x1183b0
movq %rax, %r12
movq %r15, %rdi
callq 0x102934
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x1188e8
movq %rax, 0x18(%r12)
testq %rax, %rax
jne 0x1183a1
movq %r14, %rdi
callq 0x10297b
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x31fbb1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ccc52(%rip), %rsi    # 0x2e5013
leaq 0x1d6fcb(%rip), %rdx    # 0x2ef393
leaq 0x21ae8b(%rip), %rcx    # 0x33325a
leaq 0x21aea4(%rip), %r8     # 0x33327a
pushq $0x68
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: gt_sequence_node_out_visitor_class
const GtNodeVisitorClass* gt_sequence_node_out_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSequenceNodeOutVisitor),
                                    sequence_node_out_visitor_free,
                                    sequence_node_out_visitor_comment_node,
                                    sequence_node_out_visitor_feature_node,
                                    sequence_node_out_visitor_region_node,
                                    sequence_node_out_visitor_sequence_node,
                                    sequence_node_out_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc,
                                           sequence_node_out_visitor_meta_node);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x32543a(%rip)    # 0x43d830
jne 0x118444
leaq 0x383(%rip), %rax       # 0x118782
movq %rax, (%rsp)
leaq 0x48(%rip), %rsi        # 0x118452
leaq 0x5f(%rip), %rdx        # 0x118470
leaq 0x108(%rip), %rcx       # 0x118520
leaq 0x1b1(%rip), %r8        # 0x1185d0
leaq 0x25a(%rip), %r9        # 0x118680
pushq $0x30
popq %rdi
callq 0x102cd0
movq %rax, 0x3253fb(%rip)    # 0x43d830
leaq 0x3f6(%rip), %rsi       # 0x118832
movq %rax, %rdi
callq 0x102d5f
callq 0x69ede
movq 0x3253e0(%rip), %rax    # 0x43d830
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_comment_node
static int sequence_node_out_visitor_comment_node(GtNodeVisitor *nv,
                                                   GtCommentNode *cn,
                                                   GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && cn);

  gt_queue_add(v->node_buffer, cn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1183e8
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq %rax, %r14
testq %r15, %r15
je 0x1184a2
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1184ea
testq %rbx, %rbx
je 0x1184c0
testq %r14, %r14
je 0x1184c0
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x9e2d1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x31faa1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ccb42(%rip), %rsi    # 0x2e5013
leaq 0x209bbf(%rip), %rdx    # 0x322097
leaq 0x21ae3b(%rip), %rcx    # 0x33331a
leaq 0x21ae0b(%rip), %r8     # 0x3332f1
pushq $0x4b
jmp 0x118512
movq 0x31fa77(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ccb18(%rip), %rsi    # 0x2e5013
leaq 0x1cccbd(%rip), %rdx    # 0x2e51bf
leaq 0x21ae11(%rip), %rcx    # 0x33331a
leaq 0x21ade1(%rip), %r8     # 0x3332f1
pushq $0x4a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_feature_node
static int sequence_node_out_visitor_feature_node(GtNodeVisitor *nv,
                                                  GtFeatureNode *fn,
                                                  GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && fn);

  gt_queue_add(v->node_buffer, fn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1183e8
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq %rax, %r14
testq %r15, %r15
je 0x118552
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0x11859a
testq %rbx, %rbx
je 0x118570
testq %r14, %r14
je 0x118570
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x9e2d1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x31f9f1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cca92(%rip), %rsi    # 0x2e5013
leaq 0x21c9ca(%rip), %rdx    # 0x334f52
leaq 0x21adb2(%rip), %rcx    # 0x333341
leaq 0x21ad5b(%rip), %r8     # 0x3332f1
pushq $0x75
jmp 0x1185c2
movq 0x31f9c7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cca68(%rip), %rsi    # 0x2e5013
leaq 0x1ccc0d(%rip), %rdx    # 0x2e51bf
leaq 0x21ad88(%rip), %rcx    # 0x333341
leaq 0x21ad31(%rip), %r8     # 0x3332f1
pushq $0x74
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_region_node
static int sequence_node_out_visitor_region_node(GtNodeVisitor *nv,
                                                 GtRegionNode *rn,
                                                 GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && rn);

  gt_queue_add(v->node_buffer, rn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1183e8
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq %rax, %r14
testq %r15, %r15
je 0x118602
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0x11864a
testq %rbx, %rbx
je 0x118620
testq %r14, %r14
je 0x118620
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x9e2d1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x31f941(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cc9e2(%rip), %rsi    # 0x2e5013
leaq 0x209bb5(%rip), %rdx    # 0x3221ed
leaq 0x21ad29(%rip), %rcx    # 0x333368
leaq 0x21acab(%rip), %r8     # 0x3332f1
pushq $0x59
jmp 0x118672
movq 0x31f917(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1cc9b8(%rip), %rsi    # 0x2e5013
leaq 0x1ccb5d(%rip), %rdx    # 0x2e51bf
leaq 0x21acff(%rip), %rcx    # 0x333368
leaq 0x21ac81(%rip), %r8     # 0x3332f1
pushq $0x58
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390