LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xa420d
movq %rdi, %rbx
leaq 0x2af1c2(%rip), %rdi    # 0x353396
leaq 0x2af1e5(%rip), %rsi    # 0x3533c0
callq 0x10cc4e
movq %rax, %r14
leaq 0x7f8c4(%rip), %rsi     # 0x123aae
movq %rax, %rdi
movq %rbx, %rdx
callq 0x10cd8d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10d766
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19b99
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_dev.c
// Function: gt_dev_runner
static int gt_dev_runner(int argc, const char **argv, int parsed_args,
                         void *tool_arguments, GtError *err)
{
  GtToolbox *dev_toolbox = tool_arguments;
  GtToolfunc toolfunc;
  GtTool *tool = NULL;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(dev_toolbox);

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

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

  /* free */
  gt_cstr_array_delete(nargv);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
movq %rsi, %r12
movl %edi, %ebp
testq %r8, %r8
je 0xa4240
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xa4318
testq %r15, %r15
je 0xa4313
movslq %r14d, %r13
movq (%r12,%r13,8), %rsi
movq %r15, %rdi
callq 0x123a17
movq (%r12,%r13,8), %rdx
testb %al, %al
je 0xa4281
leaq (%r12,%r13,8), %r13
movq %r15, %rdi
movq %rdx, %rsi
callq 0x123a87
movq %rax, %r12
testq %rax, %rax
je 0xa429c
movq $0x0, (%rsp)
jmp 0xa42b1
leaq 0x2af190(%rip), %rsi    # 0x353418
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xa42fa
movq (%r13), %rsi
movq %r15, %rdi
callq 0x1239f1
movq %rax, (%rsp)
testq %rax, %rax
je 0xa431d
movq %rbx, %rdi
callq 0x101b22
movq %r13, %rdi
movq %rax, %rsi
callq 0xe8b1a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x101ada
subl %r14d, %ebp
testq %r12, %r12
je 0xa42e7
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r12
jmp 0xa42f8
movq (%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x123470
movl %eax, %ebx
movq %r15, %rdi
callq 0xe8d46
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19c3e
callq 0x19bd0
callq 0x19c07
nop
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, %r15d
movq %rsi, %r14
movl %edi, %ebp
testq %r8, %r8
je 0xa43bb
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xa4432
subl %r15d, %ebp
movslq %r15d, %rax
leaq (%r14,%rax,8), %rsi
movl %ebp, %edi
callq 0x14d00b
movq %rax, %r14
xorl %r15d, %r15d
testq %rax, %rax
je 0xa43ef
callq 0x13d96d
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x18c917
movq %rax, %r12
jmp 0xa43f5
xorl %r12d, %r12d
xorl %r13d, %r13d
testq %r12, %r12
je 0xa4410
movq %r12, %rdi
movq %rbx, %rsi
callq 0x16adca
movl %eax, %r15d
movq %r13, %rdi
callq 0x13d961
movq %r14, %rdi
callq 0x16ac6e
movq %r12, %rdi
callq 0x16ac6e
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19cac
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2af070(%rip), %rdx    # 0x3534d3
movl $0x1, %edi
movl $0x20, %esi
movl $0x21, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x10ff7c
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa44da
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040fc
movq 0x10(%rbx), %rdi
callq 0x110231
movq 0x8(%rbx), %rdi
callq 0x121b03
movq (%rbx), %rdi
callq 0x121b03
leaq 0x2af007(%rip), %rsi    # 0x3534d3
movq %rbx, %rdi
movl $0x30, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa457b
movq %rdi, %rbx
leaq 0x2af016(%rip), %rdi    # 0x353509
leaq 0x2af02c(%rip), %rsi    # 0x353526
callq 0x10cc4e
movq %rax, %r14
movq (%rbx), %rdx
leaq 0x33fad3(%rip), %rdi    # 0x3e3fdf
leaq 0x2af049(%rip), %rsi    # 0x35355c
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %r14, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x8(%rbx), %rdx
leaq 0x2e292b(%rip), %rdi    # 0x386e66
leaq 0x2af02f(%rip), %rsi    # 0x353571
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %r14, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x19ce3
// File: /workspace/github_c_makefile_star2_O1/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 0xa45ab
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xa462d
testq %r14, %r14
je 0xa4628
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r15,%rax,8), %rsi
movl %ebp, %edi
callq 0x14d00b
movq %rax, %r15
movq (%r14), %rdi
callq 0x120d23
movq %rax, %r12
movq 0x8(%r14), %rdi
callq 0x120d23
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x13dad4
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x14e310
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16adca
movl %eax, %ebx
movq %r14, %rdi
callq 0x16ac6e
movq %r12, %rdi
callq 0x16ac6e
movq %r15, %rdi
callq 0x16ac6e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x19d51
callq 0x19d1a
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x12391a
movq %rax, %rbx
callq 0xa59e8
leaq 0x2aef09(%rip), %rsi    # 0x353595
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa5e30
leaq 0x334f3d(%rip), %rsi    # 0x3d95e0
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa6e9c
leaq 0x2f853f(%rip), %rsi    # 0x39cbf9
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa7e6c
leaq 0x2d0fd3(%rip), %rsi    # 0x3756a4
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa6276
leaq 0x2e0d12(%rip), %rsi    # 0x3853fa
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa6a38
leaq 0x2de0e0(%rip), %rsi    # 0x3827df
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa530a
leaq 0x2aec42(%rip), %rsi    # 0x353358
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xa8184
leaq 0x31b956(%rip), %rsi    # 0x3c0083
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa4793
movq %rdi, %rbx
leaq 0x2ab398(%rip), %rdi    # 0x34faf2
leaq 0x2aee80(%rip), %rsi    # 0x3535e1
callq 0x10cc4e
movq %rax, %r14
leaq 0x7f33e(%rip), %rsi     # 0x123aae
movq %rax, %rdi
movq %rbx, %rdx
callq 0x10cd8d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10d766
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19d88
// File: /workspace/github_c_makefile_star2_O1/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 0xa47c6
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xa485d
testq %r15, %r15
je 0xa4858
movslq %r14d, %rax
leaq (%r12,%rax,8), %r13
movq (%r13), %rsi
movq %r15, %rdi
callq 0x1239f1
testq %rax, %rax
je 0xa4822
movq %rax, %r12
movq %rbx, %rdi
callq 0x101b22
movq %r13, %rdi
movq %rax, %rsi
callq 0xe8b1a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x101ada
subl %r14d, %ebp
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x123470
movl %eax, %ebx
jmp 0xa483f
movq (%r13), %rdx
leaq 0x2aee0c(%rip), %rsi    # 0x353639
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0xe8d46
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19df6
callq 0x19dbf
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2aedf4(%rip), %rdx    # 0x353688
movl $0x1, %edi
movl $0x60, %esi
movl $0x3f, %ecx
callq 0x1093ef
movq %rax, %rbx
movb $0x0, 0x3(%rax)
movw $0x0, 0x6(%rax)
movl $0x0, 0x14(%rax)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0xc(%rbx)
callq 0x1208f8
movq %rax, 0x30(%rbx)
callq 0x1208f8
movq %rax, 0x38(%rbx)
callq 0x1208f8
movq %rax, 0x40(%rbx)
callq 0x1208f8
movq %rax, 0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa494e
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x121b03
movq 0x50(%rbx), %rdi
callq 0x10f386
movq 0x58(%rbx), %rdi
callq 0x10f386
movq 0x40(%rbx), %rdi
callq 0x121b03
movq 0x48(%rbx), %rdi
callq 0x121b03
leaq 0x2aed48(%rip), %rsi    # 0x353688
movq %rbx, %rdi
movl $0x59, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa5220
movq %rsi, %rbx
movl 0x1c(%rdi), %eax
testl %eax, %eax
je 0xa51cc
movl %eax, (%rbx)
cmpl 0x8(%rdi), %eax
jbe 0xa51de
leaq 0x2aea04(%rip), %rsi    # 0x353bc2
movq %rdx, %rdi
movl %eax, %edx
xorl %eax, %eax
callq 0x1019cf
jmp 0xa51fb
movl 0x8(%rdi), %eax
cmpl $0x20, %eax
movl $0x20, %ecx
cmovbl %eax, %ecx
movl %ecx, (%rbx)
jmp 0xa5200
cmpl $0x21, %eax
jb 0xa5200
leaq 0x2ae9fa(%rip), %rsi    # 0x353be4
movq %rdx, %rdi
movl %eax, %edx
movl $0x20, %ecx
xorl %eax, %eax
callq 0x1019cf
movb $0x1, %bpl
jmp 0xa5202
xorl %ebp, %ebp
movl (%rbx), %esi
leaq 0x2bc163(%rip), %rdi    # 0x36136e
xorl %eax, %eax
callq 0x108e02
cmpl $0x0, (%rbx)
je 0xa5225
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x19f48
callq 0x19f0f
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xa5289
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
leaq 0x2ae9e8(%rip), %r14    # 0x353c2b
movq %r14, %rsi
movl $0x72, %edx
callq 0x109670
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x73, %edx
callq 0x109670
movq 0x20(%rbx), %rdi
movq %r14, %rsi
movl $0x74, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x75, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa52e6
movq %rdx, %rbx
movq %rsi, %r14
callq 0xec1e8
cmpq %rbx, %rax
jbe 0xa5300
movq 0x10(%r14), %rsi
movq 0x20(%r14), %rdi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xefa70
testq %rax, %rax
je 0xa52ea
movq 0x20(%r14), %rcx
subq -0x8(%rcx,%rax,8), %rbx
jb 0xa5305
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 0xa52f8
xorl %eax, %eax
jmp 0xa52f8
movq 0x28(%r14), %rax
movq (%rax), %rax
incq %rax
imulq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19f81
callq 0x19fba
// File: /workspace/github_c_makefile_star2_O1/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 0xa53fb
movq %rdi, %r14
leaq 0x2ae965(%rip), %rdi    # 0x353cd6
leaq 0x2ae975(%rip), %rsi    # 0x353ced
callq 0x10cc4e
movq %rax, %rbx
leaq 0x2ae994(%rip), %rdi    # 0x353d1b
leaq 0x2ae993(%rip), %rsi    # 0x353d21
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f4c7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x8(%r14), %rdx
leaq 0x2ae9a2(%rip), %rdi    # 0x353d50
leaq 0x2ae9a2(%rip), %rsi    # 0x353d57
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
addq $0x9, %r14
movq %r14, %rdi
callq 0x10f473
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %rbx, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10d784
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x19ff3
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa5b43
movq %rdi, %rbx
leaq 0x2ae663(%rip), %rdi    # 0x3540da
leaq 0x2ae675(%rip), %rsi    # 0x3540f3
callq 0x10cc4e
movq %rax, %r14
leaq 0x2b0ee2(%rip), %rdi    # 0x35696f
leaq 0x2ae68e(%rip), %rsi    # 0x354122
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x18(%rbx), %rdx
leaq 0x2cb2ad(%rip), %rdi    # 0x370d61
leaq 0x2ae677(%rip), %rsi    # 0x354132
movq $-0x1, %rcx
callq 0x10f4c7
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x1(%rbx), %rdx
leaq 0x2c7fcb(%rip), %rdi    # 0x36daa8
leaq 0x2ae664(%rip), %rsi    # 0x354148
xorl %ecx, %ecx
callq 0x10f451
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x10(%rbx), %rdx
leaq 0x2ae65d(%rip), %rdi    # 0x35415e
leaq 0x2ae65d(%rip), %rsi    # 0x354165
movq $-0x1, %rcx
callq 0x10f4c7
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1014bc
movq %r14, %rdi
movl $0x1, %esi
callq 0x10d766
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a1b9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_encseq_check.c
// Function: gt_encseq_check_option_parser_new
static GtOptionParser* gt_encseq_check_option_parser_new(void *tool_arguments)
{
  GtEncseqCheckArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GT_UNUSED GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [file]",
                            "Check the consistency of an encoded "
                            "sequence file.");

  option = gt_option_new_uword("scantrials", "specify number of scan trials",
                               &arguments->scantrials, 0);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword("multicharcmptrials",
                               "specify number of multicharacter trials",
                               &arguments->multicharcmptrials, 0);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword_min_max("prefixlength",
                                       "prefix length",
                                       &arguments->prefixlength, 0,
                                       0, 32);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("nocheckunit","do not run checkextractunitatpos",
                              &arguments->nocheckunit, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("mirrored","use mirrored encseq",
                              &arguments->mirror, 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_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa5f96
movq %rdi, %r14
leaq 0x2ad826(%rip), %rdi    # 0x3536c2
leaq 0x2ae3de(%rip), %rsi    # 0x354281
callq 0x10cc4e
movq %rax, %rbx
leaq 0x2ae402(%rip), %rdi    # 0x3542b4
leaq 0x2ae406(%rip), %rsi    # 0x3542bf
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f4c7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x8(%r14), %rdx
leaq 0x2ae404(%rip), %rdi    # 0x3542dd
leaq 0x2ae410(%rip), %rsi    # 0x3542f0
xorl %ecx, %ecx
callq 0x10f4c7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x10(%r14), %rdx
leaq 0x302769(%rip), %rdi    # 0x3a8666
leaq 0x2ae414(%rip), %rsi    # 0x354318
movl $0x20, %r9d
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x10f81b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x1a(%r14), %rdx
leaq 0x2ae3fc(%rip), %rdi    # 0x354326
leaq 0x2ae401(%rip), %rsi    # 0x354332
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x19(%r14), %rdx
leaq 0x2b0a21(%rip), %rdi    # 0x35696f
leaq 0x2ae3fe(%rip), %rsi    # 0x354353
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
addq $0x18, %r14
movq %r14, %rdi
callq 0x10f473
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10d766
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a25e
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x48(%rsi), %rdi
callq 0x120d4c
testq %rax, %rax
je 0xa61d0
movq 0x48(%r14), %rdi
callq 0x120d23
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1187a3
testl %eax, %eax
js 0xa6265
movl %eax, 0x40(%r14)
movq 0x28(%r14), %rax
cmpq $-0x1, %rax
je 0xa61f7
cmpq $-0x1, 0x30(%r14)
je 0xa61f1
cmpq $-0x1, 0x50(%r14)
je 0xa61f1
leaq 0x2ae1b1(%rip), %rsi    # 0x3543a0
jmp 0xa625b
cmpq $-0x1, %rax
jne 0xa6205
cmpq $-0x1, 0x30(%r14)
jne 0xa6205
cmpq $-0x1, 0x50(%r14)
je 0xa622a
movq 0x8(%r14), %rdi
callq 0x120d23
leaq 0x2dcc19(%rip), %rsi    # 0x382e2e
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xa622a
leaq 0x2ae1a7(%rip), %rsi    # 0x3543cf
jmp 0xa625b
cmpq $-0x1, 0x18(%r14)
jne 0xa6238
cmpq $-0x1, 0x20(%r14)
je 0xa6272
movq 0x8(%r14), %rdi
callq 0x120d23
leaq 0x2abe2c(%rip), %rsi    # 0x352074
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xa6272
leaq 0x2ae1bc(%rip), %rsi    # 0x354417
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
jmp 0xa626a
// File: /workspace/github_c_makefile_star2_O1/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 0x2ae1ac(%rip), %rdx    # 0x354452
movl $0x1, %edi
movl $0x58, %esi
movl $0x2f, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
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_O1/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 0xa632d
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x48(%rbx), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x1017c9
leaq 0x2ae133(%rip), %rsi    # 0x354452
movq %rbx, %rdi
movl $0x40, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa6ab7
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1017c9
movq 0x10(%rbx), %rdi
callq 0x121b03
leaq 0x2adc3c(%rip), %rsi    # 0x3546e5
movq %rbx, %rdi
movl $0x33, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2adc3b(%rip), %rdi    # 0x354702
leaq 0x2adc66(%rip), %rsi    # 0x354734
callq 0x10cc4e
movq %rax, %rbx
leaq 0x8(%r14), %rdx
leaq 0x2adc93(%rip), %rdi    # 0x354774
leaq 0x2adc96(%rip), %rsi    # 0x35477e
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x9(%r14), %rdx
leaq 0x2adc92(%rip), %rdi    # 0x354797
leaq 0x2adc99(%rip), %rsi    # 0x3547a5
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x10(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x100e34
movq %rax, (%r14)
addq $0xa, %r14
movq %r14, %rdi
callq 0x10f473
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10d766
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x120955
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x12097f
movq %rbx, %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x10415c
testb %al, %al
je 0xa6e83
movq %rbx, %rdi
callq 0x120d23
movq %rax, %rdi
callq 0x104631
movq %rax, %r14
jmp 0xa6e86
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x121b03
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xa6f1c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x1040fc
movq 0x8(%rbx), %rdi
callq 0x110231
leaq 0x2ad9ec(%rip), %rsi    # 0x3548fa
movq %rbx, %rdi
movl $0x34, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa7f63
movq %rdi, %rbx
leaq 0x2abdd8(%rip), %rdi    # 0x353cd6
leaq 0x2acf06(%rip), %rsi    # 0x354e0b
callq 0x10cc4e
movq %rax, %r14
leaq 0x10(%rbx), %rdx
leaq 0x2acf1d(%rip), %rdi    # 0x354e35
leaq 0x2acf20(%rip), %rsi    # 0x354e3f
movl $0x1, %ecx
callq 0x10f451
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq (%rbx), %rdi
addq $0x8, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10d784
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1a5de
// File: /workspace/github_c_makefile_star2_O1/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 0x2acd09(%rip), %rdx    # 0x354ebd
movl $0x1, %edi
movl $0x48, %esi
movl $0x38, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
movq %rax, 0x38(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa8236
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x121b03
movq 0x28(%rbx), %rdi
callq 0x1017c9
leaq 0x2acc95(%rip), %rsi    # 0x354ebd
movq %rbx, %rdi
movl $0x48, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa8398
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xa83f9
testq %r14, %r14
je 0xa83f4
movq 0x38(%r14), %rdi
callq 0x120d4c
xorl %ebp, %ebp
testq %rax, %rax
je 0xa83d0
movq 0x38(%r14), %rdi
callq 0x120d23
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1187a3
testl %eax, %eax
js 0xa83cb
movl %eax, 0x30(%r14)
jmp 0xa83d0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $-0x1, 0x40(%r14)
jne 0xa83ed
leaq 0x2acb92(%rip), %rsi    # 0x354f70
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1a6f3
callq 0x1a6ba
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_eval.c
// Function: gt_eval_runner
int gt_eval_runner(GT_UNUSED int argc, const char **argv, int parsed_args,
                   void *tool_arguments, GtError *err)
{
  EvalArguments *arguments = tool_arguments;
  GtNodeStream *reference_stream,
               *prediction_stream;
  GtStreamEvaluator *evaluator;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create the reference stream */
  reference_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args]);
  if (arguments->verbose)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) reference_stream);

  /* create the prediction stream */
  prediction_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args + 1]);
  if (arguments->verbose)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) prediction_stream);

  /* create the stream evaluator */
  evaluator = gt_stream_evaluator_new(reference_stream, prediction_stream,
                                      arguments->nuceval, arguments->evalLTR,
                                      arguments->LTRdelta);

  /* compute the evaluation */
  had_err = gt_stream_evaluator_evaluate(evaluator, arguments->verbose,
                                         arguments->exondiff,
                                         arguments->exondiffcollapsed, NULL,
                                         err);

  /* show the evaluation */
  if (!had_err)
    gt_stream_evaluator_show(evaluator, arguments->outfp);

  /* free */
  gt_stream_evaluator_delete(evaluator);
  gt_node_stream_delete(prediction_stream);
  gt_node_stream_delete(reference_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r12
testq %r8, %r8
je 0xa89eb
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0xa8a9d
testq %rbx, %rbx
je 0xa8a98
movslq %ebp, %r13
movq (%r12,%r13,8), %rdi
callq 0x14d0a8
movq %rax, %r15
cmpb $0x1, (%rbx)
jne 0xa8a10
movq %r15, %rdi
callq 0x14ce62
movq 0x8(%r12,%r13,8), %rdi
callq 0x14d0a8
movq %rax, %r12
cmpb $0x1, (%rbx)
jne 0xa8a2a
movq %r12, %rdi
callq 0x14ce62
movzbl 0x3(%rbx), %edx
movzbl 0x4(%rbx), %ecx
movq 0x8(%rbx), %r8
movq %r15, %rdi
movq %r12, %rsi
callq 0x183604
movq %rax, %r13
movzbl (%rbx), %esi
movzbl 0x1(%rbx), %edx
movzbl 0x2(%rbx), %ecx
movq %rax, %rdi
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1839f4
movl %eax, %ebp
testl %eax, %eax
jne 0xa8a6f
movq 0x18(%rbx), %rsi
movq %r13, %rdi
callq 0x18502d
movq %r13, %rdi
callq 0x1856b7
movq %r12, %rdi
callq 0x16ac6e
movq %r15, %rdi
callq 0x16ac6e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1a849
callq 0x1a810
// File: /workspace/github_c_makefile_star2_O1/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 0xa8b22
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040fc
movq 0x10(%rbx), %rdi
callq 0x110231
leaq 0x2ac567(%rip), %rsi    # 0x35507b
movq %rbx, %rdi
movl $0x34, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2ac5f0(%rip), %rdx    # 0x3552a7
movl $0x1, %edi
movl $0x38, %esi
movl $0x31, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x17b020
movq %rax, 0x18(%rbx)
callq 0x10ff7c
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_extractfeat.c
// Function: gt_extractfeat_arguments_delete
static void gt_extractfeat_arguments_delete(void *tool_arguments)
{
  GtExtractFeatArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_str_delete(arguments->type);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xa8d30
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x1040fc
movq 0x28(%rbx), %rdi
callq 0x110231
movq 0x18(%rbx), %rdi
callq 0x17b067
movq 0x10(%rbx), %rdi
callq 0x121b03
leaq 0x2ac585(%rip), %rsi    # 0x3552a7
movq %rbx, %rdi
movl $0x40, %edx
popq %rbx
jmp 0x109670
retq