LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x23364
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
leaq 0x2c6e98(%rip), %rsi    # 0x2ea1f0
pushq $0x31
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x233ff
movq %rdi, %r14
leaq 0x2c2d13(%rip), %rdi    # 0x2e608f
leaq 0x2c6e99(%rip), %rsi    # 0x2ea21c
callq 0x97df5
movq %rax, %rbx
leaq 0x8(%r14), %rdx
leaq 0x2c6ed5(%rip), %rdi    # 0x2ea26b
leaq 0x2c6eda(%rip), %rsi    # 0x2ea277
movl $0x12c, %ecx            # imm = 0x12C
callq 0x9a9e6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r14, %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%r14), %rdi
addq $0x18, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9b6d7
leaq 0xc410d(%rip), %rsi     # 0xe74ec
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98045
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x98c29
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x414b62(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c1c03(%rip), %rsi    # 0x2e5013
leaq 0x32523c(%rip), %rdx    # 0x348653
leaq 0x2c6de5(%rip), %rcx    # 0x2ea203
leaq 0x2c6dcb(%rip), %r8     # 0x2ea1f0
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2345d
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x234fe
testq %r14, %r14
je 0x234d4
movslq %ebp, %rax
movq (%r15,%rax,8), %rdi
callq 0xdef57
movq %rax, %r15
cmpb $0x1, (%r14)
jne 0x23486
cmpq $0x0, 0x18(%r14)
je 0x23486
movq %r15, %rdi
callq 0xdeb22
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0xc7f77
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0xe07df
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102b93
movl %eax, %ebx
movq %r14, %rdi
callq 0x10297b
movq %r12, %rdi
callq 0x10297b
movq %r15, %rdi
callq 0x10297b
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x414a8d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c1b2e(%rip), %rsi    # 0x2e5013
leaq 0x325167(%rip), %rdx    # 0x348653
leaq 0x2c6db9(%rip), %rcx    # 0x2ea2ac
leaq 0x2c6cf6(%rip), %r8     # 0x2ea1f0
pushq $0x5b
jmp 0x23526
movq 0x414a63(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c1b04(%rip), %rsi    # 0x2e5013
leaq 0x2c1ca9(%rip), %rdx    # 0x2e51bf
leaq 0x2c6d8f(%rip), %rcx    # 0x2ea2ac
leaq 0x2c6ccc(%rip), %r8     # 0x2ea1f0
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x237fb
movq %rdi, %rbx
leaq 0x2c6bc2(%rip), %rdi    # 0x2ea386
leaq 0x2c6be5(%rip), %rsi    # 0x2ea3b0
callq 0x97df5
movq %rax, %r14
leaq 0x8d6be(%rip), %rsi     # 0xb0e98
movq %rax, %rdi
movq %rbx, %rdx
callq 0x98045
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x98be7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x414766(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c1807(%rip), %rsi    # 0x2e5013
leaq 0x2c6b3b(%rip), %rdx    # 0x2ea34e
leaq 0x2c6b40(%rip), %rcx    # 0x2ea35a
leaq 0x2c6b52(%rip), %r8     # 0x2ea373
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x23a7e
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x23ae8
subl %ebp, %ebx
movslq %ebp, %rax
leaq (%r15,%rax,8), %rsi
movl %ebx, %edi
callq 0xdeebd
movq %rax, %rbx
testq %rax, %rax
je 0x23ac8
callq 0xcdf39
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12bf59
testq %rax, %rax
je 0x23ac8
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x102b93
movl %eax, %ebp
movq %r12, %rdi
callq 0xcdf2d
jmp 0x23acd
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x10297b
movq %r15, %rdi
callq 0x10297b
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x414479(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c151a(%rip), %rsi    # 0x2e5013
leaq 0x2c16bf(%rip), %rdx    # 0x2e51bf
leaq 0x2c69ae(%rip), %rcx    # 0x2ea4b5
leaq 0x2c693d(%rip), %r8     # 0x2ea44b
pushq $0x3e
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2c6978(%rip), %rdx    # 0x2ea4c3
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x21
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0x9b6b4
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23bba
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
movq 0x8(%rbx), %rdi
callq 0xae103
movq (%rbx), %rdi
callq 0xae103
leaq 0x2c6915(%rip), %rsi    # 0x2ea4c3
pushq $0x30
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23c5b
movq %rdi, %rbx
leaq 0x2c6926(%rip), %rdi    # 0x2ea4f9
leaq 0x2c693c(%rip), %rsi    # 0x2ea516
callq 0x97df5
movq %rax, %r14
movq (%rbx), %rdx
leaq 0x3570c3(%rip), %rdi    # 0x37acaf
leaq 0x2c6959(%rip), %rsi    # 0x2ea54c
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rax, %rdi
callq 0x9ae37
movq %r14, %rdi
movq %r15, %rsi
callq 0x97f31
movq 0x8(%rbx), %rdx
leaq 0x2fa2e3(%rip), %rdi    # 0x31defe
leaq 0x2c693f(%rip), %rsi    # 0x2ea561
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rax, %rdi
callq 0x9ae37
movq %r14, %rdi
movq %r15, %rsi
callq 0x97f31
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x414306(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c13a7(%rip), %rsi    # 0x2e5013
leaq 0x3249e0(%rip), %rdx    # 0x348653
leaq 0x2c6860(%rip), %rcx    # 0x2ea4da
leaq 0x2c6842(%rip), %r8     # 0x2ea4c3
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x23cbc
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x23d63
testq %r14, %r14
je 0x23d39
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r15,%rax,8), %rsi
movl %ebp, %edi
callq 0xdeebd
movq %rax, %r15
movq (%r14), %rdi
callq 0xad1fa
movq %rax, %r12
movq 0x8(%r14), %rdi
callq 0xad1fa
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xce090
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0xe07df
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102b93
movl %eax, %ebx
movq %r14, %rdi
callq 0x10297b
movq %r12, %rdi
callq 0x10297b
movq %r15, %rdi
callq 0x10297b
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x414228(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c12c9(%rip), %rsi    # 0x2e5013
leaq 0x324902(%rip), %rdx    # 0x348653
leaq 0x2c6819(%rip), %rcx    # 0x2ea571
leaq 0x2c6764(%rip), %r8     # 0x2ea4c3
pushq $0x5b
jmp 0x23d8b
movq 0x4141fe(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c129f(%rip), %rsi    # 0x2e5013
leaq 0x2c1444(%rip), %rdx    # 0x2e51bf
leaq 0x2c67ef(%rip), %rcx    # 0x2ea571
leaq 0x2c673a(%rip), %r8     # 0x2ea4c3
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0xb0c26
movq %rax, %rbx
callq 0x253b0
leaq 0x2c6791(%rip), %rsi    # 0x2ea585
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x25820
leaq 0x34c495(%rip), %rsi    # 0x3702a0
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x269b8
leaq 0x30fcb4(%rip), %rsi    # 0x333ad6
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x27988
leaq 0x2e8940(%rip), %rsi    # 0x30c779
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x25cc6
leaq 0x2f85da(%rip), %rsi    # 0x31c42a
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x264e0
leaq 0x2f59a8(%rip), %rsi    # 0x31980f
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x24bca
leaq 0x2c64ca(%rip), %rsi    # 0x2ea348
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x27d00
leaq 0x33302e(%rip), %rsi    # 0x356ec3
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x23ef9
movq %rdi, %rbx
leaq 0x2c2c30(%rip), %rdi    # 0x2e6af2
leaq 0x2c6708(%rip), %rsi    # 0x2ea5d1
callq 0x97df5
movq %rax, %r14
leaq 0x8cfc0(%rip), %rsi     # 0xb0e98
movq %rax, %rdi
movq %rbx, %rdx
callq 0x98045
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x98be7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x414068(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c1109(%rip), %rsi    # 0x2e5013
leaq 0x2c667f(%rip), %rdx    # 0x2ea590
leaq 0x2c6687(%rip), %rcx    # 0x2ea59f
leaq 0x2c669c(%rip), %r8     # 0x2ea5bb
pushq $0x3a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x23f5d
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x24017
testq %r15, %r15
je 0x23fed
movslq %r14d, %rax
leaq (%r12,%rax,8), %r13
movq (%r13), %rsi
movq %r15, %rdi
callq 0xb0d2d
testq %rax, %rax
je 0x23fb9
movq %rax, %r12
movq %rbx, %rdi
callq 0x8a001
movq %r13, %rdi
movq %rax, %rsi
callq 0x6c7c9
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x89f8a
subl %r14d, %ebp
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xb05a1
movl %eax, %ebx
jmp 0x23fd4
movq (%r13), %rdx
leaq 0x2c6665(%rip), %rsi    # 0x2ea629
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbx
movq %r15, %rdi
callq 0x6ca1b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x413f74(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c1015(%rip), %rsi    # 0x2e5013
leaq 0x2c658b(%rip), %rdx    # 0x2ea590
leaq 0x2c660c(%rip), %rcx    # 0x2ea618
leaq 0x2c65a8(%rip), %r8     # 0x2ea5bb
pushq $0x4c
jmp 0x2403f
movq 0x413f4a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c0feb(%rip), %rsi    # 0x2e5013
leaq 0x2c1190(%rip), %rdx    # 0x2e51bf
leaq 0x2c65e2(%rip), %rcx    # 0x2ea618
leaq 0x2c657e(%rip), %r8     # 0x2ea5bb
pushq $0x4b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x2c65e7(%rip), %rdx    # 0x2ea667
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
pushq $0x3f
popq %rcx
callq 0x9334a
movq %rax, %rbx
movb $0x0, 0x3(%rax)
andw $0x0, 0x6(%rax)
andl $0x0, 0x14(%rax)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0xc(%rbx)
callq 0xacb84
movq %rax, 0x30(%rbx)
callq 0xacb84
movq %rax, 0x38(%rbx)
callq 0xacb84
movq %rax, 0x40(%rbx)
callq 0xacb84
movq %rax, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2412e
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0xae103
movq 0x50(%rbx), %rdi
callq 0x9a8ea
movq 0x58(%rbx), %rdi
callq 0x9a8ea
movq 0x40(%rbx), %rdi
callq 0xae103
movq 0x48(%rbx), %rdi
callq 0xae103
leaq 0x2c6545(%rip), %rsi    # 0x2ea667
pushq $0x59
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x24a31
movq %rsi, %rbx
movl 0x1c(%rdi), %eax
testl %eax, %eax
je 0x249e1
movl %eax, (%rbx)
cmpl 0x8(%rdi), %eax
jbe 0x249f1
leaq 0x2c61ce(%rip), %rsi    # 0x2eaba1
movq %rdx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x89dbb
jmp 0x24a0c
movl 0x8(%rdi), %eax
cmpl $0x20, %eax
pushq $0x20
popq %rcx
cmovbl %eax, %ecx
movl %ecx, (%rbx)
jmp 0x24a11
cmpl $0x21, %eax
jb 0x24a11
leaq 0x2c61c6(%rip), %rsi    # 0x2eabc3
pushq $0x20
popq %rcx
movq %rdx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x89dbb
movb $0x1, %bpl
jmp 0x24a13
xorl %ebp, %ebp
movl (%rbx), %esi
leaq 0x2d390f(%rip), %rdi    # 0x2f832b
xorl %eax, %eax
callq 0x92a82
cmpl $0x0, (%rbx)
je 0x24a5f
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x413530(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c05d1(%rip), %rsi    # 0x2e5013
leaq 0x2c6130(%rip), %rdx    # 0x2eab79
leaq 0x2c613a(%rip), %rcx    # 0x2eab8a
leaq 0x2c5c10(%rip), %r8     # 0x2ea667
movl $0xd7, %r9d
jmp 0x24a8b
movq 0x413502(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c05a3(%rip), %rsi    # 0x2e5013
leaq 0x2c6185(%rip), %rdx    # 0x2eabfc
leaq 0x2c610c(%rip), %rcx    # 0x2eab8a
leaq 0x2c5be2(%rip), %r8     # 0x2ea667
movl $0xef, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x24aed
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq 0x2c616d(%rip), %r14    # 0x2eac1c
pushq $0x72
popq %rdx
movq %r14, %rsi
callq 0x936f9
movq 0x18(%rbx), %rdi
pushq $0x73
popq %rdx
movq %r14, %rsi
callq 0x936f9
movq 0x20(%rbx), %rdi
pushq $0x74
popq %rdx
movq %r14, %rsi
callq 0x936f9
pushq $0x75
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_bench.c
// Function: gt_sortedlengthinfo_seqstart
GtUword gt_sortedlengthinfo_seqstart(const GtEncseq *encseq,
                                   const GtSortedlengthinfo *sortedlengthinfo,
                                   GtUword seqnum)
{
  if (seqnum == 0)
    return 0;
  else {
    GtUword numberofsequences = gt_encseq_num_of_sequences(encseq),
                  recordnum;

    gt_assert(seqnum < numberofsequences);
    recordnum = gt_encseq_sep2seqnum(sortedlengthinfo->seqlencount,
                                     sortedlengthinfo->numofdifferentseqlen,
                                     numberofsequences,
                                     seqnum);
    if (recordnum == 0)
      return (sortedlengthinfo->seqlentab[0] + 1) * seqnum;

    gt_assert(seqnum >= sortedlengthinfo->seqlencount[recordnum-1]);
    return sortedlengthinfo->seqlenseppos[recordnum-1] +
           (sortedlengthinfo->seqlentab[recordnum] + 1) *
           (seqnum - sortedlengthinfo->seqlencount[recordnum-1]) + 1;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0x24b4a
movq %rdx, %rbx
movq %rsi, %r14
callq 0x705a1
cmpq %rbx, %rax
jbe 0x24b64
movq 0x10(%r14), %rsi
movq 0x20(%r14), %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x74a31
testq %rax, %rax
je 0x24b4e
movq 0x20(%r14), %rcx
subq -0x8(%rcx,%rax,8), %rbx
jb 0x24b92
movq 0x18(%r14), %rcx
movq 0x28(%r14), %rdx
movq -0x8(%rcx,%rax,8), %rcx
movq (%rdx,%rax,8), %rax
incq %rax
imulq %rbx, %rax
addq %rcx, %rax
incq %rax
jmp 0x24b5c
xorl %eax, %eax
jmp 0x24b5c
movq 0x28(%r14), %rax
movq (%rax), %rax
incq %rax
imulq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x4133fd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c049e(%rip), %rsi    # 0x2e5013
leaq 0x2c60bc(%rip), %rdx    # 0x2eac38
leaq 0x2c60d0(%rip), %rcx    # 0x2eac53
leaq 0x2c6092(%rip), %r8     # 0x2eac1c
movl $0xfb, %r9d
jmp 0x24bbe
movq 0x4133cf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c0470(%rip), %rsi    # 0x2e5013
leaq 0x2c60c6(%rip), %rdx    # 0x2eac70
leaq 0x2c60a2(%rip), %rcx    # 0x2eac53
leaq 0x2c6064(%rip), %r8     # 0x2eac1c
movl $0x103, %r9d            # imm = 0x103
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_bench.c
// Function: gt_encseq_bench_option_parser_new
static GtOptionParser* gt_encseq_bench_option_parser_new(void *tool_arguments)
{
  GtEncseqBenchArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;

  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] indexname",
                            "Perform benchmark on extractions from encseq.");

  option = gt_option_new_uword("ccext", "specify number of random character "
                                        "extractions",
                               &arguments->ccext, 0UL);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("solepr", "prepare data structure for sequences "
                                         "ordered by their length",
                               &arguments->sortlenprepare, false);
  gt_option_parser_add_option(op, option);

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

  gt_option_parser_set_min_max_args(op, 1U, 1U);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x24cb0
movq %rdi, %r14
leaq 0x2c609c(%rip), %rdi    # 0x2eacc7
leaq 0x2c60ac(%rip), %rsi    # 0x2eacde
callq 0x97df5
movq %rax, %rbx
leaq 0x2c60cb(%rip), %rdi    # 0x2ead0c
leaq 0x2c60ca(%rip), %rsi    # 0x2ead12
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a9e6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x8(%r14), %rdx
leaq 0x2c60d9(%rip), %rdi    # 0x2ead41
leaq 0x2c60d9(%rip), %rsi    # 0x2ead48
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
addq $0x9, %r14
movq %r14, %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
pushq $0x1
popq %rdx
movq %rbx, %rdi
movl %edx, %esi
callq 0x98c6b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x4132b1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2c0352(%rip), %rsi    # 0x2e5013
leaq 0x32398b(%rip), %rdx    # 0x348653
leaq 0x2c5fd6(%rip), %rcx    # 0x2eaca5
leaq 0x2c5f46(%rip), %r8     # 0x2eac1c
pushq $0x38
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_bitextract.c
// Function: gt_encseq_bitextract_option_parser_new
static GtOptionParser* gt_encseq_bitextract_option_parser_new(void
                                                                *tool_arguments)
{
  GtEncseqBitextractArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[option ...] [indexname]",
                            "Extracts internal data from encoded sequences.");

  option = gt_option_new_bool("mirrored", "mirror sequence",
                               &arguments->mirror, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword("stoppos", "output stop positions",
                               &arguments->stoppos, GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("specialranges", "output special ranges",
                               &arguments->specialranges, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword("bitpos", "extract and display "
                                         "two bit encoding for position",
                               &arguments->bitpos, GT_UNDEF_UWORD);
  gt_option_parser_add_option(op, option);

  gt_encseq_options_add_readmode_option(op, arguments->readmode);

  gt_option_parser_set_min_args(op, 1U);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x254fc
movq %rdi, %rbx
leaq 0x2c5c93(%rip), %rdi    # 0x2eb0cb
leaq 0x2c5ca5(%rip), %rsi    # 0x2eb0e4
callq 0x97df5
movq %rax, %r14
leaq 0x2c84f1(%rip), %rdi    # 0x2ed93f
leaq 0x2c5cbe(%rip), %rsi    # 0x2eb113
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x18(%rbx), %rdx
leaq 0x2e2614(%rip), %rdi    # 0x307a89
leaq 0x2c5ca7(%rip), %rsi    # 0x2eb123
pushq $-0x1
popq %r15
movq %r15, %rcx
callq 0x9a9e6
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x1(%rbx), %rdx
leaq 0x2df386(%rip), %rdi    # 0x304824
leaq 0x2c5c94(%rip), %rsi    # 0x2eb139
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x10(%rbx), %rdx
leaq 0x2c5c8d(%rip), %rdi    # 0x2eb14f
leaq 0x2c5c8d(%rip), %rsi    # 0x2eb156
movq %r15, %rcx
callq 0x9a9e6
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x88fcd
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x98be7
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x412a65(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bfb06(%rip), %rsi    # 0x2e5013
leaq 0x32313f(%rip), %rdx    # 0x348653
leaq 0x2c5b89(%rip), %rcx    # 0x2eb0a4
leaq 0x2c5b61(%rip), %r8     # 0x2eb083
pushq $0x38
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_decode.c
// Function: gt_encseq_decode_arguments_check
int gt_encseq_decode_arguments_check(GT_UNUSED int rest_argc,
                                     void *tool_arguments,
                                     GtError* err)
{
  GtEncseqDecodeArguments *args = (GtEncseqDecodeArguments*) tool_arguments;
  int had_err = 0;
  int rval;

  if (gt_str_length(args->dir) > 0) {
    rval = gt_readmode_parse(gt_str_get(args->dir), err);
    if (rval < 0)
      had_err = -1;
    else
      args->rm = (GtReadmode) rval;
  }
  if (!had_err && args->seqrng.start != GT_UNDEF_UWORD &&
        args->seqrng.end != GT_UNDEF_UWORD && args->seq != GT_UNDEF_UWORD) {
    gt_error_set(err, "'-seq' and '-seqrange' cannot be used together");
    had_err = -1;
  }
  if (!had_err && (args->seqrng.start != GT_UNDEF_UWORD ||
        args->seqrng.end != GT_UNDEF_UWORD || args->seq != GT_UNDEF_UWORD)
        && strcmp(gt_str_get(args->mode), "fasta") != 0) {
    gt_error_set(err, "'-seq' and '-seqrange' can only be used with the "
                      "'-output fasta' option");
    had_err = -1;
  }
  if (!had_err && (args->rng.start != GT_UNDEF_UWORD ||
        args->rng.end != GT_UNDEF_UWORD)
        && strcmp(gt_str_get(args->mode), "concat") != 0) {
    gt_error_set(err, "'-range' can only be used with the "
                      "'-output concat' option");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x48(%rsi), %rdi
callq 0xad289
pushq $-0x1
popq %rbx
testq %rax, %rax
je 0x25c2c
movq 0x48(%r15), %rdi
callq 0xad1fa
movq %rax, %rdi
movq %r14, %rsi
callq 0xa45d3
testl %eax, %eax
js 0x25cba
movl %eax, 0x40(%r15)
movq 0x30(%r15), %rax
cmpq $-0x1, 0x28(%r15)
je 0x25c4d
cmpq $-0x1, %rax
je 0x25c5a
cmpq $-0x1, 0x50(%r15)
je 0x25c5a
leaq 0x2c5746(%rip), %rsi    # 0x2eb391
jmp 0x25cb0
cmpq $-0x1, %rax
jne 0x25c5a
cmpq $-0x1, 0x50(%r15)
je 0x25c7f
movq 0x8(%r15), %rdi
callq 0xad1fa
leaq 0x2f41f4(%rip), %rsi    # 0x319e5e
movq %rax, %rdi
callq 0x179e0
testl %eax, %eax
je 0x25c7f
leaq 0x2c5743(%rip), %rsi    # 0x2eb3c0
jmp 0x25cb0
cmpq $-0x1, 0x18(%r15)
jne 0x25c8d
cmpq $-0x1, 0x20(%r15)
je 0x25cc2
movq 0x8(%r15), %rdi
callq 0xad1fa
leaq 0x2c33c7(%rip), %rsi    # 0x2e9064
movq %rax, %rdi
callq 0x179e0
testl %eax, %eax
je 0x25cc2
leaq 0x2c5758(%rip), %rsi    # 0x2eb408
movq %r14, %rdi
xorl %eax, %eax
callq 0x89dbb
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
xorl %ebx, %ebx
jmp 0x25cba
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_decode.c
// Function: gt_encseq_decode_arguments_new
static void* gt_encseq_decode_arguments_new(void)
{
  GtEncseqDecodeArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->mode = gt_str_new();
  arguments->sepchar = gt_str_new();
  arguments->dir = gt_str_new();
  arguments->seqrng.start = arguments->seqrng.end = GT_UNDEF_UWORD;
  arguments->rng.start = arguments->rng.end = GT_UNDEF_UWORD;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c574d(%rip), %rdx    # 0x2eb443
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
pushq $0x2f
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x48(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x18(%rbx)
movdqu %xmm0, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_decode.c
// Function: gt_encseq_decode_arguments_delete
static void gt_encseq_decode_arguments_delete(void *tool_arguments)
{
  GtEncseqDecodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->mode);
  gt_str_delete(arguments->sepchar);
  gt_str_delete(arguments->dir);
  gt_encseq_options_delete(arguments->eopts);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x25d75
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x48(%rbx), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0x89b38
leaq 0x2c56da(%rip), %rsi    # 0x2eb443
pushq $0x40
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_encode.c
// Function: gt_encseq_encode_arguments_delete
static void gt_encseq_encode_arguments_delete(void *tool_arguments)
{
  GtEncseqEncodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_encseq_options_delete(arguments->eopts);
  gt_str_delete(arguments->indexname);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x26557
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x89b38
movq 0x10(%rbx), %rdi
callq 0xae103
leaq 0x2c518b(%rip), %rsi    # 0x2eb6d6
pushq $0x33
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_encode.c
// Function: gt_encseq_encode_option_parser_new
static GtOptionParser* gt_encseq_encode_option_parser_new(void *tool_arguments)
{
  GtOptionParser *op;
  GtOption *option;
  GtEncseqEncodeArguments *arguments =
                                      (GtEncseqEncodeArguments*) tool_arguments;

  /* init */
  op = gt_option_parser_new("sequence_file [sequence_file "
                            "[sequence_file ...]]",
                            "Encode sequence files (FASTA/FASTQ, GenBank, "
                            "EMBL) efficiently.");

  /* -showstats */
  option = gt_option_new_bool("showstats",
                              "show compression results",
                              &arguments->showstats,
                              false);
  gt_option_parser_add_option(op, option);

  /* -no_esq_header */
  option = gt_option_new_bool("no_esq_header",
                              "omit the header in the .esq file",
                              &arguments->no_esq_header,
                              false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  /* encoded sequence options */
  arguments->eopts = gt_encseq_options_register_encoding(op,
                                                         arguments->indexname,
                                                         NULL);

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

  gt_option_parser_set_min_args(op, 1);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x2c518c(%rip), %rdi    # 0x2eb6f3
leaq 0x2c51b7(%rip), %rsi    # 0x2eb725
callq 0x97df5
movq %rax, %rbx
leaq 0x8(%r14), %rdx
leaq 0x2c51e4(%rip), %rdi    # 0x2eb765
leaq 0x2c51e7(%rip), %rsi    # 0x2eb76f
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x9(%r14), %rdx
leaq 0x2c51e3(%rip), %rdi    # 0x2eb788
leaq 0x2c51ea(%rip), %rsi    # 0x2eb796
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
movq 0x10(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x888e4
movq %rax, (%r14)
addq $0xa, %r14
movq %r14, %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x98be7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_encode.c
// Function: index_size
static off_t index_size(const char *prefix, const char *suffix)
{
 off_t size = 0;
 GtStr *index_name = gt_str_new_cstr(prefix);
 gt_str_append_cstr(index_name, suffix);
 if (gt_file_exists(gt_str_get(index_name))) {
   size = gt_file_size(gt_str_get(index_name));
 }
 gt_str_delete(index_name);
 return size;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0xacbd1
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xacbfb
movq %rbx, %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x8da98
testb %al, %al
je 0x269a2
movq %rbx, %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x8e0a6
movq %rax, %r14
jmp 0x269a5
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0xae103
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_info.c
// Function: gt_encseq_info_arguments_delete
static void gt_encseq_info_arguments_delete(void *tool_arguments)
{
  GtEncseqInfoArguments *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 0x26a30
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x8da06
movq 0x8(%rbx), %rdi
callq 0x9ba24
leaq 0x2c4ea7(%rip), %rsi    # 0x2eb8cb
pushq $0x34
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_md5.c
// Function: gt_encseq_md5_option_parser_new
static GtOptionParser* gt_encseq_md5_option_parser_new(void *tool_arguments)
{
  GtEncseqInfoArguments *arguments = tool_arguments;
  GtOption *option;
  GtOptionParser *op;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] indexname",
                            "Display MD5 sums for an encoded sequence.");

  /* -fromindex */
  option = gt_option_new_bool("fromindex", "use MD5 table from .md5 file",
                              &arguments->fromindex, true);
  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_min_max_args(op, 1, 1);
  return op;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x27a6e
movq %rdi, %rbx
leaq 0x2c32b5(%rip), %rdi    # 0x2eacc7
leaq 0x2c43c3(%rip), %rsi    # 0x2ebddc
callq 0x97df5
movq %rax, %r14
leaq 0x10(%rbx), %rdx
leaq 0x2c43da(%rip), %rdi    # 0x2ebe06
leaq 0x2c43dd(%rip), %rsi    # 0x2ebe10
pushq $0x1
popq %rbp
movl %ebp, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq (%rbx), %rdi
addq $0x8, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
movq %r14, %rdi
movl %ebp, %esi
movl %ebp, %edx
callq 0x98c6b
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x4104f3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bd594(%rip), %rsi    # 0x2e5013
leaq 0x320bcd(%rip), %rdx    # 0x348653
leaq 0x2c432f(%rip), %rcx    # 0x2ebdbc
leaq 0x2c430e(%rip), %r8     # 0x2ebda2
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_sample.c
// Function: gt_encseq_sample_arguments_new
static void* gt_encseq_sample_arguments_new(void)
{
  GtEncseqSampleArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->mode = gt_str_new();
  arguments->sepchar = gt_str_new();
  arguments->dir = gt_str_new();
  arguments->seqrng.start = arguments->seqrng.end = GT_UNDEF_UWORD;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c415e(%rip), %rdx    # 0x2ebe8e
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
pushq $0x38
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x38(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_sample.c
// Function: gt_encseq_sample_arguments_delete
static void gt_encseq_sample_arguments_delete(void *tool_arguments)
{
  GtEncseqSampleArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_delete(arguments->mode);
    gt_str_delete(arguments->sepchar);
    gt_str_delete(arguments->dir);
    gt_encseq_options_delete(arguments->eopts);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x27daa
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0xae103
movq 0x28(%rbx), %rdi
callq 0x89b38
leaq 0x2c40f0(%rip), %rsi    # 0x2ebe8e
pushq $0x48
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_encseq_sample.c
// Function: gt_encseq_sample_arguments_check
static int gt_encseq_sample_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  GtEncseqSampleArguments *args = (GtEncseqSampleArguments *) tool_arguments;
  int rval;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(args);

  if (gt_str_length(args->dir) > 0) {
    rval = gt_readmode_parse(gt_str_get(args->dir), err);
    if (rval < 0)
      had_err = -1;
    else
      args->rm = (GtReadmode) rval;
  }
  if (args->len == GT_UNDEF_UWORD) {
    gt_error_set(err, "length must be specified");
    return -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0x27f38
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x27fbe
testq %r14, %r14
je 0x27f90
movq 0x38(%r14), %rdi
callq 0xad289
xorl %ebp, %ebp
testq %rax, %rax
je 0x27f6e
movq 0x38(%r14), %rdi
callq 0xad1fa
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa45d3
testl %eax, %eax
js 0x27f6b
movl %eax, 0x30(%r14)
jmp 0x27f6e
pushq $-0x1
popq %rbp
cmpq $-0x1, 0x40(%r14)
jne 0x27f89
leaq 0x2c3fc5(%rip), %rsi    # 0x2ebf41
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x40ffd1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bd072(%rip), %rsi    # 0x2e5013
leaq 0x2bfb54(%rip), %rdx    # 0x2e7afc
leaq 0x2c3f71(%rip), %rcx    # 0x2ebf20
leaq 0x2c3ed8(%rip), %r8     # 0x2ebe8e
movl $0x95, %r9d
jmp 0x27fea
movq 0x40ffa3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bd044(%rip), %rsi    # 0x2e5013
leaq 0x2bd1e9(%rip), %rdx    # 0x2e51bf
leaq 0x2c3f43(%rip), %rcx    # 0x2ebf20
leaq 0x2c3eaa(%rip), %r8     # 0x2ebe8e
movl $0x94, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_eval.c
// Function: gt_eval_arguments_delete
static void gt_eval_arguments_delete(void *tool_arguments)
{
  EvalArguments *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 0x28796
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
leaq 0x2c38c2(%rip), %rsi    # 0x2ec04c
pushq $0x34
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_extractfeat.c
// Function: gt_extractfeat_arguments_new
static void* gt_extractfeat_arguments_new(void)
{
  GtExtractFeatArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->type = gt_str_new();
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c3925(%rip), %rdx    # 0x2ec278
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
pushq $0x31
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0x116724
movq %rax, 0x18(%rbx)
callq 0x9b6b4
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq