LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2b953
movq 0x61067e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ea6e7(%rip), %rsi    # 0x516013
leaq 0x54f22c(%rip), %rdx    # 0x57ab5f
leaq 0x4ef912(%rip), %rcx    # 0x51b24c
leaq 0x4ef8f8(%rip), %r8     # 0x51b239
movl $0x39, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2b955
leaq 0x4eb74c(%rip), %rdi    # 0x5170a8
leaq 0x4ef902(%rip), %rsi    # 0x51b265
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
addq $0x8, %rdx
leaq 0x4ef937(%rip), %rdi    # 0x51b2b4
leaq 0x4ef93c(%rip), %rsi    # 0x51b2c0
movl $0x12c, %ecx            # imm = 0x12C
callq 0xf5fe0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
callq 0xf5f90
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rdi
leaq 0x1562f8(%rip), %rsi    # 0x181ce0
xorl %eax, %eax
movl %eax, %edx
callq 0xf1770
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xf29e0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2ba85
movq 0x30(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2ba4d
jmp 0x2ba85
movq 0x61054c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ea5b5(%rip), %rsi    # 0x516013
leaq 0x4ea75a(%rip), %rdx    # 0x5161bf
leaq 0x4ef889(%rip), %rcx    # 0x51b2f5
leaq 0x4ef7c6(%rip), %r8     # 0x51b239
movl $0x5a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ba87
jmp 0x2ba89
cmpq $0x0, 0x10(%rsp)
jne 0x2bac9
movq 0x610508(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ea571(%rip), %rsi    # 0x516013
leaq 0x54f0b6(%rip), %rdx    # 0x57ab5f
leaq 0x4ef845(%rip), %rcx    # 0x51b2f5
leaq 0x4ef782(%rip), %r8     # 0x51b239
movl $0x5b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2bacb
movq 0x48(%rsp), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1747b0
movq %rax, 0x28(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x2bb03
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2bb03
movq 0x28(%rsp), %rdi
callq 0x1741e0
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x14b000
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x176d50
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1b1f90
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1b1cb0
movq 0x20(%rsp), %rdi
callq 0x1b1cb0
movq 0x28(%rsp), %rdi
callq 0x1b1cb0
movl 0xc(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2bfb3
movq 0x61001e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ea087(%rip), %rsi    # 0x516013
leaq 0x4ef404(%rip), %rdx    # 0x51b397
leaq 0x4ef409(%rip), %rcx    # 0x51b3a3
leaq 0x4ef41b(%rip), %r8     # 0x51b3bc
movl $0x5d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2bfb5
leaq 0x4ef413(%rip), %rdi    # 0x51b3cf
leaq 0x4ef436(%rip), %rsi    # 0x51b3f9
callq 0xf1420
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0xf79c4(%rip), %rsi     # 0x1239a0
callq 0xf1770
movq (%rsp), %rdi
movl $0x1, %esi
callq 0xf2980
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_dot.c
// Function: gt_dot_option_parser_new
static GtOptionParser* gt_dot_option_parser_new(void *tool_arguments)
{
  GT_UNUSED GtDotArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GT_UNUSED GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [files]",
                            "Prints feature graphs in dotfile format.");

  return op;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2c343
movq 0x60fc8e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e9cf7(%rip), %rsi    # 0x516013
leaq 0x54e83c(%rip), %rdx    # 0x57ab5f
leaq 0x4ef17d(%rip), %rcx    # 0x51b4a7
leaq 0x4ef163(%rip), %r8     # 0x51b494
movl $0x2e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c345
leaq 0x4ef174(%rip), %rdi    # 0x51b4c0
leaq 0x4ef182(%rip), %rsi    # 0x51b4d5
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2c408
movq 0x30(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2c3d0
jmp 0x2c408
movq 0x60fbc9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e9c32(%rip), %rsi    # 0x516013
leaq 0x4e9dd7(%rip), %rdx    # 0x5161bf
leaq 0x4ef10f(%rip), %rcx    # 0x51b4fe
leaq 0x4ef09e(%rip), %r8     # 0x51b494
movl $0x3e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c40a
movl 0x54(%rsp), %edi
subl 0x44(%rsp), %edi
movq 0x48(%rsp), %rsi
movslq 0x44(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1746b0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2c459
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x159b40
movq (%rsp), %rdi
movq %rax, %rsi
movq %rsi, 0x10(%rsp)
callq 0x1f6b70
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2c47e
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1b1f90
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x159b20
movq 0x18(%rsp), %rdi
callq 0x1b1cb0
movq 0x20(%rsp), %rdi
callq 0x1b1cb0
movl 0xc(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x20, %esi
leaq 0x4ef02a(%rip), %rdx    # 0x51b50c
movl $0x21, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2c54d
jmp 0x2c59a
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4eef7c(%rip), %rsi    # 0x51b50c
movl $0x30, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2c5f3
movq 0x60f9de(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e9a47(%rip), %rsi    # 0x516013
leaq 0x54e58c(%rip), %rdx    # 0x57ab5f
leaq 0x4eef49(%rip), %rcx    # 0x51b523
leaq 0x4eef2b(%rip), %r8     # 0x51b50c
movl $0x39, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c5f5
leaq 0x4eef46(%rip), %rdi    # 0x51b542
leaq 0x4eef5c(%rip), %rsi    # 0x51b55f
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdx
leaq 0x583683(%rip), %rdi    # 0x5afc9f
leaq 0x4eef72(%rip), %rsi    # 0x51b595
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf6ca0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x523a3c(%rip), %rdi    # 0x550096
leaq 0x4eef49(%rip), %rsi    # 0x51b5aa
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf6ca0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x2c725
movq 0x40(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2c6ed
jmp 0x2c725
movq 0x60f8ac(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e9915(%rip), %rsi    # 0x516013
leaq 0x4e9aba(%rip), %rdx    # 0x5161bf
leaq 0x4eeeae(%rip), %rcx    # 0x51b5ba
leaq 0x4eedf9(%rip), %r8     # 0x51b50c
movl $0x5a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c727
jmp 0x2c729
cmpq $0x0, 0x38(%rsp)
jne 0x2c769
movq 0x60f868(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e98d1(%rip), %rsi    # 0x516013
leaq 0x54e416(%rip), %rdx    # 0x57ab5f
leaq 0x4eee6a(%rip), %rcx    # 0x51b5ba
leaq 0x4eedb5(%rip), %r8     # 0x51b50c
movl $0x5b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2c76b
movl 0x64(%rsp), %edi
subl 0x54(%rsp), %edi
movq 0x58(%rsp), %rsi
movslq 0x54(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1746b0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11dee0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x159d50
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x176d50
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1b1f90
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1b1cb0
movq 0x28(%rsp), %rdi
callq 0x1b1cb0
movq 0x30(%rsp), %rdi
callq 0x1b1cb0
movl 0x1c(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
callq 0x1235b0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x2ec10
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x4eed34(%rip), %rsi    # 0x51b5ce
callq 0x1235f0
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x2f3d0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x577c03(%rip), %rsi    # 0x5a44c0
callq 0x1235f0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x31190
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x5397c0(%rip), %rsi    # 0x5660a0
callq 0x1235f0
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x32d40
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0x511848(%rip), %rsi    # 0x53e14b
callq 0x1235f0
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x2fb00
movq 0x20(%rsp), %rdi
movq %rax, %rdx
leaq 0x521ca4(%rip), %rsi    # 0x54e5ca
callq 0x1235f0
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x309c0
movq 0x28(%rsp), %rdi
movq %rax, %rdx
leaq 0x51ee96(%rip), %rsi    # 0x54b7df
callq 0x1235f0
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x2df40
movq 0x30(%rsp), %rdi
movq %rax, %rdx
leaq 0x4eea25(%rip), %rsi    # 0x51b391
callq 0x1235f0
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x33270
movq 0x38(%rsp), %rdi
movq %rax, %rdx
leaq 0x55cf5f(%rip), %rsi    # 0x5898ee
callq 0x1235f0
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2ca23
movq 0x60f5ae(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e9617(%rip), %rsi    # 0x516013
leaq 0x4eebd6(%rip), %rdx    # 0x51b5d9
leaq 0x4eebde(%rip), %rcx    # 0x51b5e8
leaq 0x4eebf3(%rip), %r8     # 0x51b604
movl $0x3a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ca25
leaq 0x4eb0de(%rip), %rdi    # 0x517b0a
leaq 0x4eebe7(%rip), %rsi    # 0x51b61a
callq 0xf1420
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0xf6f54(%rip), %rsi     # 0x1239a0
callq 0xf1770
movq (%rsp), %rdi
movl $0x1, %esi
callq 0xf2980
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x60, %esi
leaq 0x4eea1e(%rip), %rdx    # 0x51b6c0
movl $0x3f, %ecx
callq 0xe83c0
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x0, 0x3(%rax)
movq (%rsp), %rax
movb $0x0, 0x7(%rax)
movq (%rsp), %rax
movb $0x0, 0x6(%rax)
movq (%rsp), %rax
movl $0x0, 0x14(%rax)
movq (%rsp), %rax
movl $0x0, 0xc(%rax)
movq (%rsp), %rax
movl $0x1, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x48(%rax)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq (%rsp), %rax
movq $0x0, 0x20(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2cd6d
jmp 0x2cdd7
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4ee8f3(%rip), %rsi    # 0x51b6c0
movl $0x59, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2dc28
movq 0x60e3a9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e8412(%rip), %rsi    # 0x516013
leaq 0x4edfca(%rip), %rdx    # 0x51bbd2
leaq 0x4edfd4(%rip), %rcx    # 0x51bbe3
leaq 0x4edaaa(%rip), %r8     # 0x51b6c0
movl $0xd7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2dc2a
movq 0x20(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jbe 0x2dca8
movq 0x20(%rsp), %rax
movl 0x1c(%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jbe 0x2dc76
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %edx
leaq 0x4edf92(%rip), %rsi    # 0x51bbfa
movb $0x0, %al
callq 0xd88c0
movb $0x1, 0xf(%rsp)
jmp 0x2dca6
movq 0x18(%rsp), %rax
cmpl $0x20, (%rax)
jbe 0x2dca4
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %edx
leaq 0x4edf89(%rip), %rsi    # 0x51bc1c
movl $0x20, %ecx
movb $0x0, %al
callq 0xd88c0
movb $0x1, 0xf(%rsp)
jmp 0x2dca6
jmp 0x2dcd9
movq 0x20(%rsp), %rcx
movl $0x20, %eax
cmpl 0x8(%rcx), %eax
jae 0x2dcc2
movl $0x20, %eax
movl %eax, 0x8(%rsp)
jmp 0x2dcce
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %esi
leaq 0x4fb72f(%rip), %rdi    # 0x529416
movb $0x0, %al
callq 0xe7740
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
ja 0x2dd30
movq 0x60e2a1(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e830a(%rip), %rsi    # 0x516013
leaq 0x4edf45(%rip), %rdx    # 0x51bc55
leaq 0x4edecc(%rip), %rcx    # 0x51bbe3
leaq 0x4ed9a2(%rip), %r8     # 0x51b6c0
movl $0xef, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2dd32
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x2ddac
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x4edf08(%rip), %rsi    # 0x51bc63
movl $0x72, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x4edeef(%rip), %rsi    # 0x51bc63
movl $0x73, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x4eded6(%rip), %rsi    # 0x51bc63
movl $0x74, %edx
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x4edec1(%rip), %rsi    # 0x51bc63
movl $0x75, %edx
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2ddd9
movq $0x0, 0x30(%rsp)
jmp 0x2df2c
movq 0x28(%rsp), %rdi
callq 0xa9d50
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
jb 0x2de2c
movq 0x60e1a5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e820e(%rip), %rsi    # 0x516013
leaq 0x4ede73(%rip), %rdx    # 0x51bc7f
leaq 0x4ede87(%rip), %rcx    # 0x51bc9a
leaq 0x4ede49(%rip), %r8     # 0x51bc63
movl $0xfb, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2de2e
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0xafcb0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2de7c
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rax
addq $0x1, %rax
imulq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2df2c
jmp 0x2de7e
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x20(%rcx), %rcx
movq 0x8(%rsp), %rdx
subq $0x1, %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x2ded3
movq 0x60e0fe(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e8167(%rip), %rsi    # 0x516013
leaq 0x4ede04(%rip), %rdx    # 0x51bcb7
leaq 0x4edde0(%rip), %rcx    # 0x51bc9a
leaq 0x4edda2(%rip), %r8     # 0x51bc63
movl $0x103, %r9d            # imm = 0x103
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ded5
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x8(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
addq $0x1, %rcx
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq 0x20(%rsi), %rsi
movq 0x8(%rsp), %rdi
subq $0x1, %rdi
subq (%rsi,%rdi,8), %rdx
imulq %rdx, %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2e033
movq 0x60df9e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e8007(%rip), %rsi    # 0x516013
leaq 0x54cb4c(%rip), %rdx    # 0x57ab5f
leaq 0x4edcd2(%rip), %rcx    # 0x51bcec
leaq 0x4edc42(%rip), %r8     # 0x51bc63
movl $0x38, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2e035
leaq 0x4edcd2(%rip), %rdi    # 0x51bd0e
leaq 0x4edce2(%rip), %rsi    # 0x51bd25
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x4edcfa(%rip), %rdi    # 0x51bd53
leaq 0x4edcf9(%rip), %rsi    # 0x51bd59
xorl %eax, %eax
movl %eax, %ecx
callq 0xf5fe0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x8, %rdx
leaq 0x4edcfb(%rip), %rdi    # 0x51bd88
leaq 0x4edcfb(%rip), %rsi    # 0x51bd8f
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
addq $0x9, %rdi
callq 0xf5f90
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xf2a40
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_encseq_bench.c
// Function: gt_sortedlengthinfo_seqnum
static GtUword gt_sortedlengthinfo_seqnum(const GtEncseq *encseq,
                                   const GtSortedlengthinfo *sortedlengthinfo,
                                   GtUword position)
{
  GtUword recordnum, totallength = gt_encseq_total_length(encseq);

  gt_assert(position < totallength);
  if (gt_encseq_get_encoded_char(encseq,position,GT_READMODE_FORWARD)
                    == (GtUchar) GT_SEPARATOR) {
    return ULONG_MAX;
  }
  recordnum = gt_encseq_sep2seqnum(sortedlengthinfo->seqlenseppos,
                                   sortedlengthinfo->numofdifferentseqlen,
                                   totallength,
                                   position);
  if (recordnum == 0)
    return position/(sortedlengthinfo->seqlentab[0]+1);
  else {
    return sortedlengthinfo->seqlencount[recordnum-1] +
           (position - sortedlengthinfo->seqlenseppos[recordnum-1])/
           (sortedlengthinfo->seqlentab[recordnum]+1);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x2ea36
movq 0x60d59b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e7604(%rip), %rsi    # 0x516013
leaq 0x4ed65d(%rip), %rdx    # 0x51c073
leaq 0x4ed66d(%rip), %rcx    # 0x51c08a
leaq 0x4ed23f(%rip), %r8     # 0x51bc63
movl $0xdf, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ea38
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0xa9da0
movzbl %al, %eax
cmpl $0xff, %eax
jne 0x2ea61
movq $-0x1, 0x30(%rsp)
jmp 0x2eb0f
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0xafcb0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2eab0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq (%rcx), %rcx
addq $0x1, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, 0x30(%rsp)
jmp 0x2eb0f
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rsp), %rdx
subq $0x1, %rdx
subq (%rcx,%rdx,8), %rax
movq 0x20(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
addq $0x1, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_encseq_bench.c
// Function: gt_bench_character_extractions
static void gt_bench_character_extractions(const GtEncseq *encseq,
                                           GtUword ccext)
{
  GtUword idx, ccsum = 0,
                totallength = gt_encseq_total_length(encseq);
  GtTimer *timer = NULL;

  if (gt_showtime_enabled()) {
    timer = gt_timer_new_with_progress_description("run character "
                                                   "extractions");
    gt_timer_start(timer);
  }
  for (idx = 0; idx < ccext; idx++) {
    GtUchar cc;
    GtUword pos = gt_rand_max(totallength-1);

    cc = gt_encseq_get_encoded_char(encseq,pos,GT_READMODE_FORWARD);
    ccsum += (GtUword) cc;
  }
  printf("ccsum="GT_WU"\n",ccsum);
  if (timer != NULL) {
    gt_timer_show_progress_final(timer, stdout);
    gt_timer_delete(timer);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0xa9d00
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
callq 0x11aa90
testb $0x1, %al
jne 0x2eb5a
jmp 0x2eb75
leaq 0x4ed544(%rip), %rdi    # 0x51c0a5
callq 0x1213a0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1213f0
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x2ebd1
movq 0x20(%rsp), %rdi
subq $0x1, %rdi
callq 0xec350
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xa9da0
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
addq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2eb7e
movq 0x28(%rsp), %rsi
leaq 0x4ed4e2(%rip), %rdi    # 0x51c0bf
movb $0x0, %al
callq 0x19070
cmpq $0x0, 0x18(%rsp)
je 0x2ec0a
movq 0x18(%rsp), %rdi
movq 0x60d340(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
callq 0x121d70
movq 0x18(%rsp), %rdi
callq 0x121f00
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_encseq_bitextract.c
// Function: gt_encseq_bitextract_arguments_delete
static void gt_encseq_bitextract_arguments_delete(void *tool_arguments)
{
  GtEncseqBitextractArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->readmode);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2ec9d
jmp 0x2ecc1
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4ed413(%rip), %rsi    # 0x51c0ca
movl $0x2f, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x2ed23
movq 0x60d2ae(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e7317(%rip), %rsi    # 0x516013
leaq 0x54be5c(%rip), %rdx    # 0x57ab5f
leaq 0x4ed3e1(%rip), %rcx    # 0x51c0eb
leaq 0x4ed3b9(%rip), %r8     # 0x51c0ca
movl $0x38, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ed25
leaq 0x4ed3e6(%rip), %rdi    # 0x51c112
leaq 0x4ed3f8(%rip), %rsi    # 0x51c12b
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
leaq 0x4efc96(%rip), %rdi    # 0x51e9df
leaq 0x4ed40a(%rip), %rsi    # 0x51c15a
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
leaq 0x50a143(%rip), %rdi    # 0x538ebe
leaq 0x4ed3e8(%rip), %rsi    # 0x51c16a
movq $-0x1, %rcx
callq 0xf5fe0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
leaq 0x506dc3(%rip), %rdi    # 0x535b75
leaq 0x4ed3c7(%rip), %rsi    # 0x51c180
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
leaq 0x4ed3b2(%rip), %rdi    # 0x51c196
leaq 0x4ed3b2(%rip), %rsi    # 0x51c19d
movq $-0x1, %rcx
callq 0xf5fe0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0xd73c0
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0xf2980
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x58, %esi
leaq 0x4ec948(%rip), %rdx    # 0x51c48a
movl $0x2f, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x48(%rax)
movq (%rsp), %rax
movq $-0x1, 0x30(%rax)
movq (%rsp), %rax
movq $-0x1, 0x28(%rax)
movq (%rsp), %rax
movq $-0x1, 0x20(%rax)
movq (%rsp), %rax
movq $-0x1, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2fbdd
jmp 0x2fc2b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xd82c0
movq 0x8(%rsp), %rdi
leaq 0x4ec869(%rip), %rsi    # 0x51c48a
movl $0x40, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_encseq_decode.c
// Function: decode_sequence_file
static int decode_sequence_file(const char *seqfile,
                                GtEncseqDecodeArguments *args,
                                GtError *err)
{
  GtEncseqLoader *encseq_loader;
  GtEncseq *encseq;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(seqfile);
  encseq_loader = gt_encseq_loader_new();
  if (!had_err && gt_encseq_options_lossless_value(args->eopts)) {
    gt_encseq_loader_require_lossless_support(encseq_loader);
  }
  if (!(encseq = gt_encseq_loader_load(encseq_loader, seqfile, err)))
    had_err = -1;
  if (!had_err && gt_encseq_options_mirrored_value(args->eopts)) {
    if (!gt_alphabet_is_dna(gt_encseq_alphabet(encseq))) {
      gt_error_set(err, "mirroring is only defined on DNA sequences");
      had_err = -1;
    }
    if (!had_err)
      had_err = gt_encseq_mirror(encseq, err);
  }
  if (!had_err)
    had_err = output_sequence(encseq, args, seqfile, err);
  gt_encseq_delete(encseq);
  gt_encseq_loader_delete(encseq_loader);
  return had_err;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2ff1b
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x2fee3
jmp 0x2ff1b
movq 0x60c0b6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e611f(%rip), %rsi    # 0x516013
leaq 0x4e62c4(%rip), %rdx    # 0x5161bf
leaq 0x4ec6da(%rip), %rcx    # 0x51c5dc
leaq 0x4ec581(%rip), %r8     # 0x51c48a
movl $0x148, %r9d            # imm = 0x148
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ff1d
jmp 0x2ff1f
cmpq $0x0, 0x30(%rsp)
jne 0x2ff5f
movq 0x60c072(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4e60db(%rip), %rsi    # 0x516013
leaq 0x54092a(%rip), %rdx    # 0x570869
leaq 0x4ec696(%rip), %rcx    # 0x51c5dc
leaq 0x4ec53d(%rip), %r8     # 0x51c48a
movl $0x149, %r9d            # imm = 0x149
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2ff61
callq 0xb7a40
movq %rax, 0x18(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x2ff90
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xd7750
testb $0x1, %al
jne 0x2ff86
jmp 0x2ff90
movq 0x18(%rsp), %rdi
callq 0xba6f0
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xb7aa0
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
jne 0x2ffb7
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
cmpl $0x0, 0xc(%rsp)
jne 0x3001f
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xd78c0
testb $0x1, %al
jne 0x2ffd2
jmp 0x3001f
movq 0x10(%rsp), %rdi
callq 0xb0f00
movq %rax, %rdi
callq 0x7f400
testb $0x1, %al
jne 0x30003
movq 0x20(%rsp), %rdi
leaq 0x4ec5fd(%rip), %rsi    # 0x51c5f1
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
cmpl $0x0, 0xc(%rsp)
jne 0x3001d
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xbbd00
movl %eax, 0xc(%rsp)
jmp 0x3001f
cmpl $0x0, 0xc(%rsp)
jne 0x30043
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x30060
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0xae070
movq 0x18(%rsp), %rdi
callq 0xb7e50
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x30a4d
jmp 0x30a7e
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xd82c0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4ebca9(%rip), %rsi    # 0x51c71d
movl $0x33, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)