LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_search.c
// Function: gt_condenseq_search_toolbox_new
static void* gt_condenseq_search_toolbox_new(void)
{
  GtToolbox *condenseq_search_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(condenseq_search_toolbox,
                      "blast", gt_condenseq_blast());
  gt_toolbox_add_tool(condenseq_search_toolbox,
                      "hmmsearch", gt_condenseq_hmmsearch());
  return condenseq_search_toolbox;
}

// Assembly:
pushq %rbx
callq 0x11dc0a
movq %rax, %rbx
callq 0x9cbb0
leaq 0x2e6b08(%rip), %rsi    # 0x387770
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0x9f7c8
leaq 0x2a8a71(%rip), %rsi    # 0x3496f0
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_search.c
// Function: gt_condenseq_search_option_parser_new
static GtOptionParser*
  gt_condenseq_search_option_parser_new(void *toolbox)
{
  GtToolbox *search_toolbox = toolbox;
  GtOptionParser *option_parser;
  gt_assert(search_toolbox);

  /* init */
  option_parser = gt_option_parser_new("tool [option ...]",
                            "Call one of the CONDENSER search tools to query "
                            "redundancy compressed genomic data.");
  gt_option_parser_set_comment_func(option_parser, gt_toolbox_show,
                                    search_toolbox);
  gt_option_parser_set_min_args(option_parser, 1U);
  return option_parser;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa0ce0
movq %rdi, %rbx
leaq 0x2a6f96(%rip), %rdi    # 0x347c3d
leaq 0x2a8f63(%rip), %rsi    # 0x349c11
callq 0x107bfe
movq %rax, %r14
leaq 0x7d0e1(%rip), %rsi     # 0x11dd9e
movq %rax, %rdi
movq %rbx, %rdx
callq 0x107d3d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x196cd
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_search.c
// Function: gt_condenseq_search_runner
static int gt_condenseq_search_runner(GT_UNUSED int argc,
                                      GT_UNUSED const char **argv,
                                      GT_UNUSED int parsed_args,
                                      void *toolbox,
                                      GtError *err)
{
  GtToolbox *search_toolbox = toolbox;
  GtTool *tool;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(search_toolbox);

  /* get search tools */
  tool = gt_toolbox_get_tool(search_toolbox, argv[parsed_args]);
  if (!tool) {
    gt_error_set(err,
                 "condenseq search tool '%s' not found; option -help lists "
                 "possible tools", argv[parsed_args]);
    had_err = -1;
  }
  /* call search tool */
  if (!had_err) {
    gt_assert(tool);
    nargv = gt_cstr_array_prefix_first(argv + parsed_args,
                                       gt_error_get_progname(err));
    gt_error_set_progname(err, nargv[0]);
    had_err = gt_tool_run(tool, argc - parsed_args, (const char**) nargv, err);
  }

  /* free */
  gt_cstr_array_delete(nargv);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
movq %rsi, %r12
movl %edi, %ebp
testq %r8, %r8
je 0xa0d13
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa0daa
testq %r15, %r15
je 0xa0da5
movslq %r14d, %rax
leaq (%r12,%rax,8), %r13
movq (%r13), %rsi
movq %r15, %rdi
callq 0x11dce1
testq %rax, %rax
je 0xa0d6f
movq %rax, %r12
movq %rbx, %rdi
callq 0xfccba
movq %r13, %rdi
movq %rax, %rsi
callq 0xe464a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xfcc72
subl %r14d, %ebp
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x11d751
movl %eax, %ebx
jmp 0xa0d8c
movq (%r13), %rdx
leaq 0x2a8f06(%rip), %rsi    # 0x349c80
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0xe487c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1973b
callq 0x19704
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_congruence.c
// Function: gt_cge_option_parser_new
static GtOptionParser* gt_cge_option_parser_new(void *tool_arguments)
{
  GtToolbox *index_toolbox = tool_arguments;
  GtOptionParser *op;

  gt_assert(index_toolbox != NULL);
  op = gt_option_parser_new(
                    "[option ...] congruence_tool [argument ...]",
                    "Call a congruence subtool and pass argument(s) to it.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, index_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  gt_option_parser_refer_to_manual(op);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa0e99
movq %rdi, %rbx
leaq 0x2a9021(%rip), %rdi    # 0x349e79
leaq 0x2a9046(%rip), %rsi    # 0x349ea5
callq 0x107bfe
movq %rax, %r14
leaq 0x7cf30(%rip), %rsi     # 0x11dd9e
movq %rax, %rdi
movq %rbx, %rdx
callq 0x107d3d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rdi
callq 0x107d2d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19772
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_congruence.c
// Function: gt_cge_runner
static int gt_cge_runner(int argc, const char **argv, int parsed_args,
                                 void *tool_arguments, GtError *err)
{
  GtToolbox *index_toolbox = tool_arguments;
  GtToolfunc toolfunc;
  GtTool *tool = NULL;
  char **nargv = NULL;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(index_toolbox != NULL);

  /* determine tool */
  if (!gt_toolbox_has_tool(index_toolbox, argv[parsed_args]))
  {
    gt_error_set(err, "congruence tool '%s' not found; option -help lists "
                   "possible tools", argv[parsed_args]);
    had_err = -1;
  }

  /* call sub-tool */
  if (!had_err)
  {
    if (!(toolfunc = gt_toolbox_get(index_toolbox, argv[parsed_args])))
    {
      tool = gt_toolbox_get_tool(index_toolbox, argv[parsed_args]);
      gt_assert(tool != NULL);
    }
    nargv = gt_cstr_array_prefix_first(argv + parsed_args,
                                       gt_error_get_progname(err));
    gt_error_set_progname(err, nargv[0]);
    if (toolfunc != NULL)
      had_err = toolfunc(argc - parsed_args, (const char**) nargv, err);
    else
      had_err = gt_tool_run(tool, argc - parsed_args, (const char**) nargv,
                            err);
  }
  gt_cstr_array_delete(nargv);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
movq %rsi, %r12
movl %edi, %ebp
testq %r8, %r8
je 0xa0ecc
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa0fa4
testq %r15, %r15
je 0xa0f9f
movslq %r14d, %r13
movq (%r12,%r13,8), %rsi
movq %r15, %rdi
callq 0x11dd07
movq (%r12,%r13,8), %rdx
testb %al, %al
je 0xa0f0d
leaq (%r12,%r13,8), %r13
movq %r15, %rdi
movq %rdx, %rsi
callq 0x11dd77
movq %rax, %r12
testq %rax, %rax
je 0xa0f28
movq $0x0, (%rsp)
jmp 0xa0f3d
leaq 0x2a8fd5(%rip), %rsi    # 0x349ee9
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xa0f86
movq (%r13), %rsi
movq %r15, %rdi
callq 0x11dce1
movq %rax, (%rsp)
testq %rax, %rax
je 0xa0fa9
movq %rbx, %rdi
callq 0xfccba
movq %r13, %rdi
movq %rax, %rsi
callq 0xe464a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xfcc72
subl %r14d, %ebp
testq %r12, %r12
je 0xa0f73
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r12
jmp 0xa0f84
movq (%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x11d751
movl %eax, %ebx
movq %r15, %rdi
callq 0xe487c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1981d
callq 0x197ab
callq 0x197e4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_congruence.c
// Function: gt_cge_spacedseed_arguments_new
static void *gt_cge_spacedseed_arguments_new(void)
{
  Cge_spacedseed_options *arguments
    = gt_malloc(sizeof (Cge_spacedseed_options));
  arguments->str_inputindex = gt_str_new();
  arguments->queryfilenames = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a8d12(%rip), %rsi    # 0x349cc8
movl $0x28, %edi
movl $0x2a, %edx
callq 0x104226
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11be10
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_congruence.c
// Function: gt_cge_spacedseed_arguments_delete
static void gt_cge_spacedseed_arguments_delete(void *tool_arguments)
{
  Cge_spacedseed_options *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->str_inputindex);
  gt_str_array_delete(arguments->queryfilenames);
  gt_option_delete(arguments->refoptionpckindex);
  gt_option_delete(arguments->refoptionesaindex);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa1021
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11c144
movq 0x20(%rbx), %rdi
callq 0x10a16a
movq 0x18(%rbx), %rdi
callq 0x10a16a
leaq 0x2a8cb5(%rip), %rsi    # 0x349cc8
movq %rbx, %rdi
movl $0x3c, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_congruence.c
// Function: gt_cge_spacedseed_arguments_check
static int gt_cge_spacedseed_arguments_check(int rest_argc,
                                             void *tool_arguments,
                                             GtError *err)
{
  Cge_spacedseed_options *arguments = tool_arguments;

  if (gt_str_length(arguments->str_inputindex) == 0)
  {
    gt_error_set(err,"missing indexname");
    return -1;
  }
  if (gt_option_is_set(arguments->refoptionesaindex))
  {
    arguments->withesa = true;
  } else
  {
    gt_assert(gt_option_is_set(arguments->refoptionpckindex));
    arguments->withesa = false;
  }
  if (rest_argc != 0)
  {
    gt_error_set(err,"superfluous file arguments");
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movq 0x8(%rsi), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0xa1198
movq 0x18(%r14), %rdi
callq 0x10ac3f
movb $0x1, %cl
testb %al, %al
jne 0xa1188
movq 0x20(%r14), %rdi
callq 0x10ac3f
testb %al, %al
je 0xa11b7
xorl %ecx, %ecx
movb %cl, (%r14)
testl %ebp, %ebp
je 0xa11b0
leaq 0x2a8c62(%rip), %rsi    # 0x349df8
jmp 0xa119f
leaq 0x2a8bf6(%rip), %rsi    # 0x349d95
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xa11b2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x19856
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_congruence.c
// Function: gt_cge_spacedseed_runner
static int gt_cge_spacedseed_runner(GT_UNUSED int argc,
                                    GT_UNUSED const char **argv,
                                    GT_UNUSED int parsed_args,
                                    void *tool_arguments,
                                    GtError *err)
{
  Cge_spacedseed_options *arguments = tool_arguments;
  GtLogger *logger = NULL;
  bool haserr = false;

  gt_assert(parsed_args == argc);
  logger = gt_logger_new(arguments->verbose, GT_LOGGER_DEFLT_PREFIX, stdout);
  if (arguments->verbose)
  {
    GtUword idx;

    printf("# %sindex=%s\n",arguments->withesa ? "esa" : "pck",
                            gt_str_get(arguments->str_inputindex));
    for (idx = 0; idx < gt_str_array_size(arguments->queryfilenames); idx++)
    {
      printf("# queryfile=%s\n",
             gt_str_array_get(arguments->queryfilenames,idx));
    }
  }
  if (gt_matchspacedseed(arguments->withesa,
                      arguments->docompare,
                      gt_str_get(arguments->str_inputindex),
                      arguments->queryfilenames,
                      arguments->verbose,
                      err) != 0)
  {
    haserr = true;
  }
  gt_logger_delete(logger);
  return haserr ? - 1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl %edi, %edx
jne 0xa12b8
movq %r8, %rbx
movq %rcx, %r14
movzbl 0x2(%rcx), %edi
movq 0x417cf8(%rip), %rax    # 0x4b8ed8
movq (%rax), %rdx
leaq 0x2a56ea(%rip), %rsi    # 0x3468d4
callq 0x103e40
movq %rax, %r15
cmpb $0x1, 0x2(%r14)
jne 0xa126e
leaq 0x2b8a25(%rip), %rax    # 0x359c25
cmpb $0x0, (%r14)
leaq 0x2ac5a3(%rip), %r12    # 0x34d7ae
cmovneq %rax, %r12
movq 0x8(%r14), %rdi
callq 0x11b0a1
leaq 0x2a8c0d(%rip), %rdi    # 0x349e2c
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
movq 0x10(%r14), %rdi
callq 0x11c131
testq %rax, %rax
je 0xa126e
leaq 0x2a8bf9(%rip), %r12    # 0x349e3a
xorl %r13d, %r13d
movq 0x10(%r14), %rdi
movq %r13, %rsi
callq 0x11bfb3
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
incq %r13
movq 0x10(%r14), %rdi
callq 0x11c131
cmpq %rax, %r13
jb 0xa1244
movzbl (%r14), %ebp
movzbl 0x1(%r14), %r12d
movq 0x8(%r14), %rdi
callq 0x11b0a1
movq 0x10(%r14), %rcx
movzbl 0x2(%r14), %r8d
movl %ebp, %edi
movl %r12d, %esi
movq %rax, %rdx
movq %rbx, %r9
callq 0x18c4e0
movl %eax, %ebx
movq %r15, %rdi
callq 0x1040e0
xorl %eax, %eax
negl %ebx
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1988d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_consensus_sa.c
// Function: gt_consensus_sa_runner
static int gt_consensus_sa_runner(GT_UNUSED int argc, const char **argv,
                                  int parsed_args,
                                  GT_UNUSED void *tool_arguments, GtError *err)
{
  GtArray *spliced_alignments;
  GtSSplicedAlignment *sa;
  GtUword i;
  int had_err = 0;
  gt_error_check(err);

  /* parse input file and store resuilts in the spliced alignment array */
  spliced_alignments = gt_array_new(sizeof (GtSSplicedAlignment*));
  had_err = gt_sspliced_alignment_parse(spliced_alignments, argv[parsed_args],
                                     err);

  if (!had_err) {
    /* sort spliced alignments */
    qsort(gt_array_get_space(spliced_alignments),
          gt_array_size(spliced_alignments),
          gt_array_elem_size(spliced_alignments),
          (GtCompare) gt_sspliced_alignment_compare_ptr);

    /* compute the consensus spliced alignments */
    gt_consensus_sa(gt_array_get_space(spliced_alignments),
                    gt_array_size(spliced_alignments),
                    gt_array_elem_size(spliced_alignments), get_genomic_range,
                    get_strand, get_exons, process_splice_form, NULL);
  }

  /* free */
  for (i = 0; i < gt_array_size(spliced_alignments); i++) {
    sa = *(GtSSplicedAlignment**) gt_array_get(spliced_alignments, i);
    gt_sspliced_alignment_delete(sa);
  }
  gt_array_delete(spliced_alignments);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movl %edx, %ebp
movq %rsi, %r15
testq %r8, %r8
je 0xa132b
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa141f
movl $0x8, %edi
callq 0xd214c
movq %rax, %rbx
movslq %ebp, %rax
movq (%r15,%rax,8), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x17a3b0
movl %eax, %ebp
testl %eax, %eax
jne 0xa13d7
movq %rbx, %rdi
callq 0xd23eb
movq %rax, %r14
movq %rbx, %rdi
callq 0xd24e0
movq %rax, %r15
movq %rbx, %rdi
callq 0xd24ed
leaq 0xd8fd1(%rip), %rcx     # 0x17a34a
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x17f60
movq %rbx, %rdi
callq 0xd23eb
movq %rax, %r14
movq %rbx, %rdi
callq 0xd24e0
movq %rax, %r15
movq %rbx, %rdi
callq 0xd24ed
leaq 0x10b(%rip), %r10       # 0xa14b7
leaq 0x71(%rip), %rcx        # 0xa1424
leaq 0x7c(%rip), %r8         # 0xa1436
leaq 0x85(%rip), %r9         # 0xa1446
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
pushq $0x0
pushq %r10
callq 0x130dfc
addq $0x10, %rsp
movq %rbx, %rdi
callq 0xd24e0
testq %rax, %rax
je 0xa140a
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x17a24b
incq %r14
movq %rbx, %rdi
callq 0xd24e0
cmpq %rax, %r14
jb 0xa13e7
movq %rbx, %rdi
callq 0xd2938
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x198c6
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_consensus_sa.c
// Function: get_exons
static void get_exons(GtArray *exon_ranges, const void *sa)
{
  GtSSplicedAlignment *alignment = *(GtSSplicedAlignment**) sa;
  GtRange exon;
  GtUword i;
  gt_assert(alignment);
  for (i = 0; i < gt_sspliced_alignment_num_of_exons(alignment); i++) {
    exon = gt_sspliced_alignment_get_exon(alignment, i);
    gt_array_add(exon_ranges, exon);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %r14
testq %r14, %r14
je 0xa14b2
movq %rdi, %rbx
movq %r14, %rdi
callq 0x17a2ce
testq %rax, %rax
je 0xa14a6
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x17a2e2
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x10, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2410
incq %r15
movq %r14, %rdi
callq 0x17a2ce
cmpq %rax, %r15
jb 0xa1471
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x19934
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_consensus_sa.c
// Function: process_splice_form
static void process_splice_form(GtArray *spliced_alignments_in_form,
                                GT_UNUSED const void *set_of_sas,
                                GT_UNUSED GtUword number_of_sas,
                                GT_UNUSED size_t size_of_sa,
                                GT_UNUSED void *userdata)
{
  GtUword i;

  printf("contains [");
  for (i = 0; i < gt_array_size(spliced_alignments_in_form); i++) {
    if (i)
      gt_xputchar(',');
    printf(""GT_WU"",
           *((GtUword*) gt_array_get(spliced_alignments_in_form, i)));
  }
  printf("]\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2a8b37(%rip), %rdi    # 0x349ffd
xorl %eax, %eax
callq 0x17070
movq %rbx, %rdi
callq 0xd24e0
testq %rax, %rax
je 0xa151b
leaq 0x31aadb(%rip), %r14    # 0x3bbfbc
xorl %r15d, %r15d
testq %r15, %r15
je 0xa14f3
movl $0x2c, %edi
callq 0x11f92c
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2207
movq (%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
incq %r15
movq %rbx, %rdi
callq 0xd24e0
cmpq %rax, %r15
jb 0xa14e4
leaq 0x3268c0(%rip), %rdi    # 0x3c7de2
popq %rbx
popq %r14
popq %r15
jmp 0x17bd0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_convertseq.c
// Function: gt_convertseq_arguments_new
static void* gt_convertseq_arguments_new(void)
{
  GtConvertseqArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->ofi = gt_output_file_info_new();
  arguments->outfp = NULL;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a8ab1(%rip), %rdx    # 0x34a008
movl $0x1, %edi
movl $0x20, %esi
movl $0x31, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x10ad60
movq %rax, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_convertseq.c
// Function: gt_convertseq_arguments_delete
static void gt_convertseq_arguments_delete(void *tool_arguments)
{
  GtConvertseqArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa15b4
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff22c
movq 0x10(%rbx), %rdi
callq 0x10b00c
leaq 0x2a8a62(%rip), %rsi    # 0x34a008
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_csa.c
// Function: gt_csa_arguments_delete
static void gt_csa_arguments_delete(void *tool_arguments)
{
  CSAArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa1b6c
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff22c
movq 0x10(%rbx), %rdi
callq 0x10b00c
leaq 0x2a8692(%rip), %rsi    # 0x34a1f0
movq %rbx, %rdi
movl $0x31, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_csa.c
// Function: gt_csa_option_parser_new
static GtOptionParser* gt_csa_option_parser_new(void *tool_arguments)
{
  CSAArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file]",
                            "Transform spliced alignments from GFF3 file into "
                            "consensus spliced alignments.");

  /* -join-length */
  option = gt_option_new_uword("join-length", "set join length for the spliced "
                               "alignment clustering", &arguments->join_length,
                               GT_DEFAULT_JOIN_LENGTH);
  gt_option_parser_add_option(op, option);

  /* -v */
  option = gt_option_new_verbose(&arguments->verbose);
  gt_option_parser_add_option(op, option);

  /* output file options */
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_max_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa1c09
movq %rdi, %r14
leaq 0x2a450b(%rip), %rdi    # 0x34608f
leaq 0x2a8691(%rip), %rsi    # 0x34a21c
callq 0x107bfe
movq %rax, %rbx
leaq 0x8(%r14), %rdx
leaq 0x2a86cd(%rip), %rdi    # 0x34a26b
leaq 0x2a86d2(%rip), %rsi    # 0x34a277
movl $0x12c, %ecx            # imm = 0x12C
callq 0x10a2ab
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r14, %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x10(%r14), %rdi
addq $0x18, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10ad87
leaq 0xaacdd(%rip), %rsi     # 0x14c8c4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x107d3d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10873c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19a82
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_csa.c
// Function: gt_csa_runner
static int gt_csa_runner(GT_UNUSED int argc, const char **argv, int parsed_args,
                         void *tool_arguments, GtError *err)
{
  GtNodeStream *gff3_in_stream, *csa_stream, *gff3_out_stream;
  CSAArguments *arguments = tool_arguments;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create the streams */
  gff3_in_stream  = gt_gff3_in_stream_new_sorted(argv[parsed_args]);
  if (arguments->verbose && arguments->outfp)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);
  csa_stream      = gt_csa_stream_new(gff3_in_stream, arguments->join_length);
  gff3_out_stream = gt_gff3_out_stream_new(csa_stream, arguments->outfp);

  /* pull the features through the stream and free them afterwards */
  had_err = gt_node_stream_pull(gff3_out_stream, err);

  /* free */
  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(csa_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
testq %r8, %r8
je 0xa1c32
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa1cae
testq %r14, %r14
je 0xa1ca9
movslq %ebp, %rax
movq (%r15,%rax,8), %rdi
callq 0x145d7c
movq %rax, %r15
cmpb $0x1, (%r14)
jne 0xa1c5b
cmpq $0x0, 0x18(%r14)
je 0xa1c5b
movq %r15, %rdi
callq 0x145b36
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x131c34
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x146fc0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162f5d
movl %eax, %ebx
movq %r14, %rdi
callq 0x162dee
movq %r12, %rdi
callq 0x162dee
movq %r15, %rdi
callq 0x162dee
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x19af0
callq 0x19ab9
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_dev.c
// Function: gt_dev_option_parser_new
static GtOptionParser* gt_dev_option_parser_new(void *tool_arguments)
{
  GtToolbox *dev_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(dev_toolbox);
  op = gt_option_parser_new("[option ...] dev_tool_name [argument ...]",
                            "Call development tool with name dev_tool_name and "
                            "pass argument(s) to it.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, dev_toolbox);
  gt_option_parser_set_min_args(op, 1);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa1f7d
movq %rdi, %rbx
leaq 0x2a8442(%rip), %rdi    # 0x34a386
leaq 0x2a8465(%rip), %rsi    # 0x34a3b0
callq 0x107bfe
movq %rax, %r14
leaq 0x7be44(%rip), %rsi     # 0x11dd9e
movq %rax, %rdi
movq %rbx, %rdx
callq 0x107d3d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19b27
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_dev.c
// Function: gt_dev_runner
static int gt_dev_runner(int argc, const char **argv, int parsed_args,
                         void *tool_arguments, GtError *err)
{
  GtToolbox *dev_toolbox = tool_arguments;
  GtToolfunc toolfunc;
  GtTool *tool = NULL;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(dev_toolbox);

  /* get development tools */
  if (!gt_toolbox_has_tool(dev_toolbox, argv[parsed_args])) {
    gt_error_set(err, "development tool '%s' not found; option -help lists "
                      "possible tools", argv[parsed_args]);
    had_err = -1;
  }

  /* call development tool */
  if (!had_err) {
    if (!(toolfunc = gt_toolbox_get(dev_toolbox, argv[parsed_args]))) {
      tool = gt_toolbox_get_tool(dev_toolbox, argv[parsed_args]);
      gt_assert(tool);
    }
    nargv = gt_cstr_array_prefix_first(argv + parsed_args,
                                       gt_error_get_progname(err));
    gt_error_set_progname(err, nargv[0]);
    if (toolfunc)
      had_err = toolfunc(argc - parsed_args, (const char**) nargv, err);
    else
      had_err = gt_tool_run(tool, argc - parsed_args, (const char**) nargv,
                            err);
  }

  /* free */
  gt_cstr_array_delete(nargv);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
movq %rsi, %r12
movl %edi, %ebp
testq %r8, %r8
je 0xa1fb0
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa2088
testq %r15, %r15
je 0xa2083
movslq %r14d, %r13
movq (%r12,%r13,8), %rsi
movq %r15, %rdi
callq 0x11dd07
movq (%r12,%r13,8), %rdx
testb %al, %al
je 0xa1ff1
leaq (%r12,%r13,8), %r13
movq %r15, %rdi
movq %rdx, %rsi
callq 0x11dd77
movq %rax, %r12
testq %rax, %rax
je 0xa200c
movq $0x0, (%rsp)
jmp 0xa2021
leaq 0x2a8410(%rip), %rsi    # 0x34a408
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xa206a
movq (%r13), %rsi
movq %r15, %rdi
callq 0x11dce1
movq %rax, (%rsp)
testq %rax, %rax
je 0xa208d
movq %rbx, %rdi
callq 0xfccba
movq %r13, %rdi
movq %rax, %rsi
callq 0xe464a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xfcc72
subl %r14d, %ebp
testq %r12, %r12
je 0xa2057
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r12
jmp 0xa2068
movq (%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x11d751
movl %eax, %ebx
movq %r15, %rdi
callq 0xe487c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19bcc
callq 0x19b5e
callq 0x19b95
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_dot.c
// Function: gt_dot_runner
static int gt_dot_runner(int argc, const char **argv, int parsed_args,
                         void *tool_arguments, GtError *err)
{
  GT_UNUSED GtDotArguments *arguments = tool_arguments;
  GtNodeStream *vs = NULL, *ins = NULL;
  GtNodeVisitor *dv = NULL;
  int had_err = 0;
  gt_error_check(err);

  ins = gt_gff3_in_stream_new_unsorted(argc - parsed_args, argv + parsed_args);
  if (ins) {
    vs = gt_visitor_stream_new(ins, (dv = gt_dot_visitor_new()));
  }
  if (vs) {
    had_err = gt_node_stream_pull(vs, err);
    gt_dot_visitor_finalize(dv);
  }
  gt_node_stream_delete(ins);
  gt_node_stream_delete(vs);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movl %edx, %ebp
movq %rsi, %r15
movl %edi, %ebx
testq %r8, %r8
je 0xa2127
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa2191
subl %ebp, %ebx
movslq %ebp, %rax
leaq (%r15,%rax,8), %rsi
movl %ebx, %edi
callq 0x145cdf
movq %rax, %rbx
testq %rax, %rax
je 0xa2171
callq 0x137291
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1841d5
testq %rax, %rax
je 0xa2171
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x162f5d
movl %eax, %ebp
movq %r12, %rdi
callq 0x137285
jmp 0xa2176
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x162dee
movq %r15, %rdi
callq 0x162dee
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x19c3a
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_dupfeat.c
// Function: gt_interfeat_arguments_new
static void* gt_interfeat_arguments_new(void)
{
  InterFeatArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->dest_type = gt_str_new();
  arguments->source_type = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a8300(%rip), %rdx    # 0x34a4c3
movl $0x1, %edi
movl $0x20, %esi
movl $0x21, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x10ad60
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_dupfeat.c
// Function: gt_interfeat_arguments_delete
static void gt_interfeat_arguments_delete(void *tool_arguments)
{
  InterFeatArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->source_type);
  gt_str_delete(arguments->dest_type);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa223a
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff22c
movq 0x10(%rbx), %rdi
callq 0x10b00c
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq (%rbx), %rdi
callq 0x11bdbf
leaq 0x2a8297(%rip), %rsi    # 0x34a4c3
movq %rbx, %rdi
movl $0x30, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_dupfeat.c
// Function: gt_interfeat_option_parser_new
static GtOptionParser* gt_interfeat_option_parser_new(void *tool_arguments)
{
  InterFeatArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;

  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Duplicate "
                            "internal feature nodes in given GFF3 files.");

  /* -outside */
  option = gt_option_new_string("dest", "set destination type",
                                arguments->dest_type, NULL);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  /* -inter */
  option = gt_option_new_string("source", "set source type",
                                arguments->source_type, NULL);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  /* output file options */
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa22db
movq %rdi, %rbx
leaq 0x2a82a6(%rip), %rdi    # 0x34a4f9
leaq 0x2a82bc(%rip), %rsi    # 0x34a516
callq 0x107bfe
movq %rax, %r14
movq (%rbx), %rdx
leaq 0x338673(%rip), %rdi    # 0x3da8df
leaq 0x2a82d9(%rip), %rsi    # 0x34a54c
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10a87b
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x8(%rbx), %rdx
leaq 0x2db85b(%rip), %rdi    # 0x37daf6
leaq 0x2a82bf(%rip), %rsi    # 0x34a561
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10a87b
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ad87
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x19c71
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_dupfeat.c
// Function: gt_interfeat_runner
static int gt_interfeat_runner(int argc, const char **argv, int parsed_args,
                          void *tool_arguments, GtError *err)
{
  InterFeatArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream,
               *dup_feature_stream,
               *gff3_out_stream;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create a gff3 input stream */
  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
                                                  argv + parsed_args);

  /* create intermediary feature stream */
  dup_feature_stream =
    gt_dup_feature_stream_new(gff3_in_stream, gt_str_get(arguments->dest_type),
                              gt_str_get(arguments->source_type));

  /* create gff3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(dup_feature_stream,
                                           arguments->outfp);

  /* pull the features through the stream and free them afterwards */
  had_err = gt_node_stream_pull(gff3_out_stream, err);

  /* free */
  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(dup_feature_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %r12d
movq %rsi, %r15
movl %edi, %ebp
testq %r8, %r8
je 0xa230b
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa238d
testq %r14, %r14
je 0xa2388
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r15,%rax,8), %rsi
movl %ebp, %edi
callq 0x145cdf
movq %rax, %r15
movq (%r14), %rdi
callq 0x11b0a1
movq %rax, %r12
movq 0x8(%r14), %rdi
callq 0x11b0a1
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1373f8
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x146fc0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162f5d
movl %eax, %ebx
movq %r14, %rdi
callq 0x162dee
movq %r12, %rdi
callq 0x162dee
movq %r15, %rdi
callq 0x162dee
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x19cdf
callq 0x19ca8
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq.c
// Function: gt_encseq_arguments_new
static void* gt_encseq_arguments_new(void)
{
  GtToolbox *encseq_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(encseq_toolbox, "bitextract", gt_encseq_bitextract());
  gt_toolbox_add_tool(encseq_toolbox, "check", gt_encseq_check());
  gt_toolbox_add_tool(encseq_toolbox, "info", gt_encseq_info());
  gt_toolbox_add_tool(encseq_toolbox, "md5", gt_encseq_md5());
  gt_toolbox_add_tool(encseq_toolbox, "decode", gt_encseq_decode());
  gt_toolbox_add_tool(encseq_toolbox, "encode", gt_encseq_encode());
  gt_toolbox_add_tool(encseq_toolbox, "bench", gt_encseq_bench());
  gt_toolbox_add_tool(encseq_toolbox, "sample", gt_encseq_sample());
  return encseq_toolbox;
}

// Assembly:
pushq %rbx
callq 0x11dc0a
movq %rax, %rbx
callq 0xa3704
leaq 0x2a8199(%rip), %rsi    # 0x34a585
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xa3b14
leaq 0x32da8d(%rip), %rsi    # 0x3cfe90
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xa4b30
leaq 0x2f1363(%rip), %rsi    # 0x39377d
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xa5b04
leaq 0x2ca023(%rip), %rsi    # 0x36c454
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xa3f37
leaq 0x2d9c42(%rip), %rsi    # 0x37c08a
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xa46d8
leaq 0x2d7062(%rip), %rsi    # 0x3794c1
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xa302e
leaq 0x2a7ed2(%rip), %rsi    # 0x34a348
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xa5e1c
leaq 0x3145d6(%rip), %rsi    # 0x3b6a63
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq.c
// Function: gt_encseq_option_parser_new
static GtOptionParser* gt_encseq_option_parser_new(void *tool_arguments)
{
  GtToolbox *encseq_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(encseq_toolbox);
  op = gt_option_parser_new("[option ...] tool [argument ...]",
                            "Call an encoded sequence manipulation tool "
                            "and pass argument(s) to it.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, encseq_toolbox);
  gt_option_parser_set_min_args(op, 1);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa24f3
movq %rdi, %rbx
leaq 0x2a4638(%rip), %rdi    # 0x346af2
leaq 0x2a8110(%rip), %rsi    # 0x34a5d1
callq 0x107bfe
movq %rax, %r14
leaq 0x7b8ce(%rip), %rsi     # 0x11dd9e
movq %rax, %rdi
movq %rbx, %rdx
callq 0x107d3d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19d16
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq.c
// Function: gt_encseq_runner
static int gt_encseq_runner(int argc, const char **argv, int parsed_args,
                            void *tool_arguments, GtError *err)
{
  GtToolbox *encseq_toolbox = tool_arguments;
  GtTool *tool = NULL;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(encseq_toolbox);

  /* get encseq tools */
  tool = gt_toolbox_get_tool(encseq_toolbox, argv[parsed_args]);
  if (!tool) {
    gt_error_set(err, "encseq tool '%s' not found; option -help lists "
                      "possible tools", argv[parsed_args]);
    had_err = -1;
  }

  /* call encseq tool */
  if (!had_err) {
    gt_assert(tool);
    nargv = gt_cstr_array_prefix_first(argv + parsed_args,
                                       gt_error_get_progname(err));
    gt_error_set_progname(err, nargv[0]);
    had_err = gt_tool_run(tool, argc - parsed_args, (const char**) nargv, err);
  }

  /* free */
  gt_cstr_array_delete(nargv);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
movq %rsi, %r12
movl %edi, %ebp
testq %r8, %r8
je 0xa2526
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa25bd
testq %r15, %r15
je 0xa25b8
movslq %r14d, %rax
leaq (%r12,%rax,8), %r13
movq (%r13), %rsi
movq %r15, %rdi
callq 0x11dce1
testq %rax, %rax
je 0xa2582
movq %rax, %r12
movq %rbx, %rdi
callq 0xfccba
movq %r13, %rdi
movq %rax, %rsi
callq 0xe464a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xfcc72
subl %r14d, %ebp
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x11d751
movl %eax, %ebx
jmp 0xa259f
movq (%r13), %rdx
leaq 0x2a809c(%rip), %rsi    # 0x34a629
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0xe487c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19d84
callq 0x19d4d
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq2spm.c
// Function: gt_encseq2spm_arguments_new
static void* gt_encseq2spm_arguments_new(void)
{
  GtEncseq2spmArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->outputspms = false;
  arguments->countspms = false;
  arguments->radixlarge = false;
  arguments->singlescan = 0;
  arguments->numofparts = 0;
  arguments->radixparts = 1U;
  arguments->encseqinput = gt_str_new();
  arguments->spmspec = gt_str_new();
  arguments->memlimitarg = gt_str_new();
  arguments->phase2extraarg = gt_str_new();
  arguments->phase2extra = 0UL; /* in bytes */
  arguments->maximumspace = 0UL; /* in bytes */
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a8073(%rip), %rdx    # 0x34a667
movl $0x1, %edi
movl $0x60, %esi
movl $0x3f, %ecx
callq 0x10436a
movq %rax, %rbx
movb $0x0, 0x3(%rax)
movw $0x0, 0x6(%rax)
movl $0x0, 0x14(%rax)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0xc(%rbx)
callq 0x11ac6c
movq %rax, 0x30(%rbx)
callq 0x11ac6c
movq %rax, 0x38(%rbx)
callq 0x11ac6c
movq %rax, 0x40(%rbx)
callq 0x11ac6c
movq %rax, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq2spm.c
// Function: gt_encseq2spm_arguments_delete
static void gt_encseq2spm_arguments_delete(void *tool_arguments)
{
  GtEncseq2spmArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->encseqinput);
  gt_str_delete(arguments->spmspec);
  gt_option_delete(arguments->refoptionmemlimit);
  gt_option_delete(arguments->refoptionphase2extra);
  gt_str_delete(arguments->memlimitarg);
  gt_str_delete(arguments->phase2extraarg);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa26ae
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x11bdbf
movq 0x50(%rbx), %rdi
callq 0x10a16a
movq 0x58(%rbx), %rdi
callq 0x10a16a
movq 0x40(%rbx), %rdi
callq 0x11bdbf
movq 0x48(%rbx), %rdi
callq 0x11bdbf
leaq 0x2a7fc7(%rip), %rsi    # 0x34a667
movq %rbx, %rdi
movl $0x59, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq2spm.c
// Function: gt_encseq2spm_arguments_check
static int gt_encseq2spm_arguments_check(int rest_argc,
                                         void *tool_arguments,
                                         GtError *err)
{
  GtEncseq2spmArguments *arguments = tool_arguments;
  bool haserr = false;

  gt_error_check(err);
  if (rest_argc != 0)
  {
    gt_error_set(err,"unnecessary arguments");
    haserr = true;
  }
  if (!haserr && gt_str_length(arguments->spmspec) > 0)
  {
    const char *spmspecstring = gt_str_get(arguments->spmspec);
    if (strcmp(spmspecstring,"show") == 0)
    {
      arguments->outputspms = true;
    } else
    {
      if (strcmp(spmspecstring,"count") == 0)
      {
        arguments->countspms = true;
      } else
      {
        gt_error_set(err,"illegal argument \"%s\" to option -spm",
                     spmspecstring);
        haserr = true;
      }
    }
  }
  if (!haserr && gt_option_is_set(arguments->refoptionmemlimit))
  {
    if (gt_option_parse_spacespec(&arguments->maximumspace,
                                  "memlimit",
                                  arguments->memlimitarg,
                                  err) != 0)
    {
      haserr = true;
    }
  }
  if (!haserr && gt_option_is_set(arguments->refoptionphase2extra))
  {
    if (gt_option_parse_spacespec(&arguments->phase2extra,
                                  "phase2extra",
                                  arguments->phase2extraarg,
                                  err) != 0)
    {
      haserr = true;
    }
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0xa29f0
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xa2aeb
testl %ebp, %ebp
je 0xa2a15
leaq 0x2a8045(%rip), %rsi    # 0x34aa40
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%r14), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0xa2a7c
movq 0x38(%r14), %rdi
callq 0x11b0a1
movq %rax, %r15
leaq 0x30db19(%rip), %rsi    # 0x3b054f
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xa2a6b
leaq 0x315651(%rip), %rsi    # 0x3b809a
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xa2a72
leaq 0x2a7ffa(%rip), %rsi    # 0x34aa56
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xfcb67
jmp 0xa2a05
movl $0x3, %eax
jmp 0xa2a77
movl $0x7, %eax
movb $0x1, (%r14,%rax)
movq 0x50(%r14), %rdi
callq 0x10ac3f
testb %al, %al
je 0xa2aaf
leaq 0x20(%r14), %rdi
movq 0x40(%r14), %rdx
leaq 0x3420b0(%rip), %rsi    # 0x3e4b48
movq %rbx, %rcx
callq 0x10ac4e
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0xa2a0a
movq 0x58(%r14), %rdi
callq 0x10ac3f
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xa2a0a
movq 0x48(%r14), %rdx
addq $0x28, %r14
leaq 0x2a7db1(%rip), %rsi    # 0x34a884
movq %r14, %rdi
movq %rbx, %rcx
callq 0x10ac4e
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0xa2a0a
callq 0x19df2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq2spm.c
// Function: gt_encseq2spm_kmersize
static bool gt_encseq2spm_kmersize(GtEncseq2spmArguments *arguments,
    unsigned int *kmersize, GtError *err)
{
  bool haserr = false;
  gt_assert(kmersize != NULL);
  if (arguments->forcek > 0)
  {
    *kmersize = arguments->forcek;
    if (*kmersize > arguments->minmatchlength)
    {
      gt_error_set(err,"argument %u to option -forcek > l",
          *kmersize);
      haserr = true;
    }
    else if (*kmersize > (unsigned int)GT_UNITSIN2BITENC)
    {
      gt_error_set(err,
          "argument %u to option -forcek > %u (machine word size/2)",
          *kmersize, (unsigned int)GT_UNITSIN2BITENC);
      haserr = true;
    }
  }
  else
  {
    *kmersize = GT_MIN((unsigned int) GT_UNITSIN2BITENC,
        arguments->minmatchlength);
  }
  gt_log_log("kmersize=%u", *kmersize);
  gt_assert(*kmersize > 0);
  return haserr;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xa2f43
movq %rsi, %rbx
movl 0x1c(%rdi), %eax
testl %eax, %eax
je 0xa2eef
movl %eax, (%rbx)
cmpl 0x8(%rdi), %eax
jbe 0xa2f01
leaq 0x2a7cc0(%rip), %rsi    # 0x34aba1
movq %rdx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0xfcb67
jmp 0xa2f1e
movl 0x8(%rdi), %eax
cmpl $0x20, %eax
movl $0x20, %ecx
cmovbl %eax, %ecx
movl %ecx, (%rbx)
jmp 0xa2f23
cmpl $0x21, %eax
jb 0xa2f23
leaq 0x2a7cb6(%rip), %rsi    # 0x34abc3
movq %rdx, %rdi
movl %eax, %edx
movl $0x20, %ecx
xorl %eax, %eax
callq 0xfcb67
movb $0x1, %bpl
jmp 0xa2f25
xorl %ebp, %ebp
movl (%rbx), %esi
leaq 0x2b53ed(%rip), %rdi    # 0x35831b
xorl %eax, %eax
callq 0x103d72
cmpl $0x0, (%rbx)
je 0xa2f48
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x19ed6
callq 0x19e9d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_encseq_bench.c
// Function: gt_sortedlengthinfo_delete
void gt_sortedlengthinfo_delete(GtSortedlengthinfo *sortedlengthinfo)
{
  if (sortedlengthinfo != NULL) {
    gt_free(sortedlengthinfo->seqlentab);
    gt_free(sortedlengthinfo->seqlenseppos);
    gt_free(sortedlengthinfo->seqlencount);
    gt_free(sortedlengthinfo);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xa2fad
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq 0x2a7cb5(%rip), %r14    # 0x34ac1c
movq %r14, %rsi
movl $0x72, %edx
callq 0x1045eb
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x73, %edx
callq 0x1045eb
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x74, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x75, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq