LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_packedindex_trsuftab.c
// Function: parseTrSufTabOptions
static GtOPrval
parseTrSufTabOptions(int *parsed_args, int argc, const char **argv,
                     struct trSufTabOptions *params, const GtStr *projectName,
                     GtError *err)
{
  GtOptionParser *op;
  GtOPrval oprval;
  GtOption *option;

  gt_error_check(err);
  op = gt_option_parser_new("indexname",
                         "Build BWT packedindex for project <indexname>.");

  gt_registerPackedIndexOptions(op, &params->idx, BWTDEFOPT_MULTI_QUERY,
                             projectName);

  option = gt_option_new_bool("v",
                           "print verbose progress information",
                           &params->verboseOutput,
                           false);
  gt_option_parser_add_option(op, option);

  gt_option_parser_set_min_max_args(op, 1, 1);
  oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
                                  err);
  /* compute parameters currently not set from command-line or
   * determined indirectly */
  gt_computePackedIndexDefaults(&params->idx, BWTBaseFeatures);

  gt_option_parser_delete(op);

  return oprval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, (%rsp)
movl %esi, %ebp
movq %rdi, %r12
testq %r9, %r9
je 0xb2be9
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xb2c88
leaq 0x2b2f3d(%rip), %rdi    # 0x365b2d
leaq 0x29f1d4(%rip), %rsi    # 0x351dcb
callq 0x107bfe
movq %rax, %r13
movq %rax, %rdi
movq %rbx, %rsi
movl $0x2, %edx
movq %r15, %rcx
callq 0x19b5b8
leaq 0x38(%rbx), %rdx
leaq 0x2dcc15(%rip), %rdi    # 0x38f832
leaq 0x29ea04(%rip), %rsi    # 0x351628
xorl %ecx, %ecx
callq 0x10a235
movq %r13, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r13, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10874b
leaq 0x6c9bd(%rip), %r8      # 0x11f60c
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq (%rsp), %rcx
movq %r14, %r9
callq 0x10875d
movl %eax, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x19b6a3
movq %r13, %rdi
callq 0x10a0b4
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d09d
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_paircmp.c
// Function: save_fastaentry
static int save_fastaentry(const char *seqpart, GT_UNUSED GtUword length,
                           void *data, GT_UNUSED GtError* err)
{
  gt_error_check(err);
  GtStrArray *fasta_sequences = (GtStrArray*) data;
  gt_str_array_add_cstr(fasta_sequences, seqpart);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0xb376a
movq %rcx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xb377f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11bee9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1d261
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_parsexrf.c
// Function: gt_parsexrf_runner
static int gt_parsexrf_runner(GT_UNUSED int argc, const char **argv,
                              int parsed_args, GT_UNUSED void *tool_arguments,
                              GtError *err)
{
  GtXRFAbbrParseTree *xpt;
  int had_err = 0;
  GtUword i;
  gt_error_check(err);

  xpt = gt_xrf_abbr_parse_tree_new(argv[parsed_args], err);
  if (!xpt)
    had_err = -1;

  if (!had_err) {
    for (i = 0; i < gt_xrf_abbr_parse_tree_num_of_entries(xpt); i++) {
      const GtXRFAbbrEntry *e = gt_xrf_abbr_parse_tree_get_entry(xpt, i);
      printf("%s\n", gt_xrf_abbr_entry_get_value(e, "abbreviation"));
    }
  }

  gt_xrf_abbr_parse_tree_delete(xpt);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, %ebp
movq %rsi, %r14
testq %r8, %r8
je 0xb383a
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xb38b3
movslq %ebp, %rax
movq (%r14,%rax,8), %rdi
movq %rbx, %rsi
callq 0x185170
movq %rax, %rbx
testq %rax, %rax
je 0xb3896
movq %rbx, %rdi
callq 0x185a15
testq %rax, %rax
je 0xb3896
xorl %r14d, %r14d
leaq 0x29e9fd(%rip), %r15    # 0x352265
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1859fd
movq %rax, %rdi
movq %r15, %rsi
callq 0x185125
movq %rax, %rdi
callq 0x17bd0
incq %r14
movq %rbx, %rdi
callq 0x185a15
cmpq %rax, %r14
jb 0xb3868
xorl %ebp, %ebp
cmpq $0x1, %rbx
sbbl %ebp, %ebp
movq %rbx, %rdi
callq 0x185978
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d2d1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_prebwt.c
// Function: gt_prebwt_option_parser_new
static GtOptionParser* gt_prebwt_option_parser_new(void *tool_arguments)
{
  Prebwtoptions *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option, *optionpck;

  gt_assert(arguments != NULL);
  arguments->indexname = gt_str_new();
  op = gt_option_parser_new("[options] -pck indexname",
                            "Precompute bwt-bounds for some prefix length.");
  gt_option_parser_set_mail_address(op, "<kurtz@zbh.uni-hamburg.de>");

  optionpck = gt_option_new_string("pck","Specify index (packed index)",
                             arguments->indexname, NULL);
  gt_option_parser_add_option(op, optionpck);
  gt_option_is_mandatory(optionpck);

  option = gt_option_new_uint_min("maxdepth",
                                  "specify maximum depth (value > 0)",
                                  &arguments->maxdepth,0,1U);
  gt_option_parser_add_option(op, option);
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xb4092
movq %rdi, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
leaq 0x29e473(%rip), %rdi    # 0x352483
leaq 0x29e485(%rip), %rsi    # 0x35249c
callq 0x107bfe
movq %rax, %r14
leaq 0x2922a6(%rip), %rsi    # 0x3462cc
movq %rax, %rdi
callq 0x107e5c
movq (%rbx), %rdx
leaq 0x299776(%rip), %rdi    # 0x34d7ae
leaq 0x295cdd(%rip), %rsi    # 0x349d1c
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a87b
addq $0x8, %rbx
leaq 0x2b3a95(%rip), %rdi    # 0x367afc
leaq 0x29e45c(%rip), %rsi    # 0x3524ca
movq %rbx, %rdx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10a51f
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d494
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_prebwt.c
// Function: gt_prebwt_runner
static int gt_prebwt_runner(GT_UNUSED int argc,
                            GT_UNUSED const char **argv,
                            GT_UNUSED int parsed_args,
                            void *tool_arguments, GtError *err)
{
  GtUword totallength = 0;
  FMindex *fmindex = NULL;
  bool haserr = false;
  GtEncseqMetadata *emd = NULL;
  Prebwtoptions *prebwtoptions = (Prebwtoptions *) tool_arguments;
  GtAlphabet *alphabet;
  const char *indexname = gt_str_get(prebwtoptions->indexname);

  emd = gt_encseq_metadata_new(indexname, err);
  if (emd == NULL) {
    haserr = true;
  }
  if (!haserr) {
    alphabet = gt_encseq_metadata_alphabet(emd);
    if (alphabet == NULL)
    {
      haserr = true;
    }
  }
  if (!haserr)
  {
    fmindex = gt_loadvoidBWTSeqForSA(indexname,false, err);
    if (fmindex == NULL)
    {
      haserr = true;
    }
  }
  if (!haserr)
  {
    unsigned int numofchars = gt_alphabet_num_of_chars(alphabet);
    Pckbuckettable *pckbt;
    totallength = gt_voidpackedindex_totallength_get(fmindex);

    pckbt = gt_pckbuckettable_new((const void *) fmindex,
                                  numofchars,
                                  totallength,
                                  prebwtoptions->maxdepth);
    if (gt_pckbuckettable_2file(indexname,pckbt,err) != 0)
    {
      haserr = true;
    }
    gt_pckbuckettable_delete(pckbt);
  }
  gt_encseq_metadata_delete(emd);
  if (fmindex != NULL)
  {
    gt_deletevoidBWTSeq(fmindex);
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r13
movq (%rcx), %rdi
callq 0x11b0a1
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xfb8bc
movq %rax, %rbx
testq %rax, %rax
je 0xb40ea
movq %r14, (%rsp)
sete %r12b
movq %rbx, %rdi
callq 0xfbec4
movq %rax, %rbp
testq %rax, %rax
sete %r14b
orb %r12b, %r14b
je 0xb40fa
xorl %r12d, %r12d
jmp 0xb411c
movq %rbx, %rdi
callq 0xfbf9f
movb $0x1, %r14b
jmp 0xb4183
movq %r15, %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x19ff2b
movq %rax, %r12
testq %rax, %rax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovnel %eax, %r14d
testb %r14b, %r14b
jne 0xb416e
movq %rbp, %rdi
callq 0xd11be
movl %eax, %ebp
movq %r12, %rdi
callq 0x1a0630
movl 0x8(%r13), %ecx
movq %r12, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x1b81ae
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq (%rsp), %rdx
callq 0x1b86cf
testl %eax, %eax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovel %eax, %r14d
movq %r13, %rdi
callq 0x1b8124
movq %rbx, %rdi
callq 0xfbf9f
testq %r12, %r12
je 0xb4183
movq %r12, %rdi
callq 0x1a0035
movzbl %r14b, %eax
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner.c
// Function: gt_readjoiner_arguments_new
static void* gt_readjoiner_arguments_new(void)
{
  GtToolbox *readjoiner_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(readjoiner_toolbox, "prefilter",
      gt_readjoiner_prefilter());
  gt_toolbox_add_tool(readjoiner_toolbox, "overlap", gt_readjoiner_overlap());
  gt_toolbox_add_tool(readjoiner_toolbox, "assembly", gt_readjoiner_assembly());
  gt_toolbox_add_hidden_tool(readjoiner_toolbox, "asqg", gt_readjoiner_asqg());
  gt_toolbox_add_hidden_tool(readjoiner_toolbox, "gfa", gt_readjoiner_gfa());
  gt_toolbox_add_hidden_tool(readjoiner_toolbox, "graph",
      gt_readjoiner_graph());
  gt_toolbox_add_hidden_tool(readjoiner_toolbox, "cgraph",
      gt_readjoiner_cgraph());
  gt_toolbox_add_hidden_tool(readjoiner_toolbox, "cnttest",
      gt_readjoiner_cnttest());
  gt_toolbox_add_hidden_tool(readjoiner_toolbox, "spmtest",
      gt_readjoiner_spmtest());
  gt_toolbox_add_hidden_tool(readjoiner_toolbox, "correct",
      gt_readjoiner_correct());
  return readjoiner_toolbox;
}

// Assembly:
pushq %rbx
callq 0x11dc0a
movq %rax, %rbx
callq 0xba114
leaq 0x29e2fc(%rip), %rsi    # 0x3524ec
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xb9784
leaq 0x2bae93(%rip), %rsi    # 0x36f09a
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xb5278
leaq 0x29e2d8(%rip), %rsi    # 0x3524f6
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xb4434
leaq 0x29e549(%rip), %rsi    # 0x35277e
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc8e
callq 0xb766c
leaq 0x29f594(%rip), %rsi    # 0x3537e0
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc8e
callq 0xb8560
leaq 0x2fbb02(%rip), %rsi    # 0x3afd65
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc8e
callq 0xb66cc
leaq 0x29f0cc(%rip), %rsi    # 0x353346
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc8e
callq 0xb6e40
leaq 0x29e26e(%rip), %rsi    # 0x3524ff
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc8e
callq 0xbb014
leaq 0x29e25f(%rip), %rsi    # 0x352507
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc8e
callq 0xb737c
leaq 0x316f5d(%rip), %rsi    # 0x3cb21c
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc8e
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner.c
// Function: gt_readjoiner_option_parser_new
static GtOptionParser* gt_readjoiner_option_parser_new(GT_UNUSED
    void *tool_arguments)
{
  GtOptionParser *op;
  op = gt_option_parser_new("[option ...] tool [argument ...]",
                 "Readjoiner: a string graph-based sequence assembler.");
  gt_option_parser_set_version_func(op, gt_readjoiner_show_version);
  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_min_args(op, 1);
  return op;
}

// Assembly:
pushq %rbx
leaq 0x292811(%rip), %rdi    # 0x346af2
leaq 0x29e227(%rip), %rsi    # 0x35250f
callq 0x107bfe
movq %rax, %rbx
leaq 0x126c59(%rip), %rsi    # 0x1daf50
movq %rax, %rdi
callq 0x107d51
leaq 0x985be(%rip), %rsi     # 0x14c8c4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x107d3d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10872d
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner.c
// Function: gt_readjoiner_runner
static int gt_readjoiner_runner(int argc, const char **argv, int parsed_args,
                         void *tool_arguments, GtError *err)
{
  GtToolbox *readjoiner_toolbox = tool_arguments;
  GtToolfunc toolfunc;
  GtTool *tool = NULL;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(readjoiner_toolbox);

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

  /* call readjoiner tool */
  if (!had_err) {
    if (!(toolfunc = gt_toolbox_get(readjoiner_toolbox, argv[parsed_args]))) {
      tool = gt_toolbox_get_tool(readjoiner_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 0xb4350
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xb4428
testq %r15, %r15
je 0xb4423
movslq %r14d, %r13
movq (%r12,%r13,8), %rsi
movq %r15, %rdi
callq 0x11dd07
movq (%r12,%r13,8), %rdx
testb %al, %al
je 0xb4391
leaq (%r12,%r13,8), %r13
movq %r15, %rdi
movq %rdx, %rsi
callq 0x11dd77
movq %rax, %r12
testq %rax, %rax
je 0xb43ac
movq $0x0, (%rsp)
jmp 0xb43c1
leaq 0x29e1ee(%rip), %rsi    # 0x352586
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xb440a
movq (%r13), %rsi
movq %r15, %rdi
callq 0x11dce1
movq %rax, (%rsp)
testq %rax, %rax
je 0xb442d
movq %rbx, %rdi
callq 0xfccba
movq %r13, %rdi
movq %rax, %rsi
callq 0xe464a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xfcc72
subl %r14d, %ebp
testq %r12, %r12
je 0xb43f7
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r12
jmp 0xb4408
movq (%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x11d751
movl %eax, %ebx
movq %r15, %rdi
callq 0xe487c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d539
callq 0x1d4cb
callq 0x1d502
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_asqg.c
// Function: gt_readjoiner_asqg_use_spmfiles
static int gt_readjoiner_asqg_use_spmfiles(GtSpmproc proc, void *procdata,
    const char *readset, unsigned int minmatchlength, unsigned int nspmfiles,
    GtBitsequence *contained, GtError *err)
{
  int had_err = 0;
  GtSpmprocSkipData skipdata;
  unsigned int i;
  GtStr *filename = gt_str_new();
  if (contained != NULL)
  {
    skipdata.to_skip = contained;
    skipdata.out.e.proc = proc;
    skipdata.out.e.data = procdata;
    skipdata.skipped_counter = 0;
  }
  for (i = 0; i < nspmfiles; i++)
  {
    gt_str_append_cstr(filename, readset);
    gt_str_append_char(filename, '.');
    gt_str_append_uint(filename, i);
    gt_str_append_cstr(filename, GT_READJOINER_SUFFIX_SPMLIST);
    had_err = gt_spmlist_parse(gt_str_get(filename),
        (GtUword)minmatchlength,
        contained == NULL ? proc : gt_spmproc_skip,
        contained == NULL ? (void*)procdata : (void*)&skipdata, err);
    gt_str_reset(filename);
  }
  gt_str_delete(filename);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x11ac6c
movq %rbx, %rcx
movq %rax, %rbx
testq %r12, %r12
je 0xb51bd
movq %r12, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
testl %ebp, %ebp
je 0xb525a
testq %r12, %r12
movl %r13d, %eax
movq %rax, 0x10(%rsp)
cmovneq 0x403d58(%rip), %rcx    # 0x4b8f30
leaq 0x18(%rsp), %rax
cmoveq %r14, %rax
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
movq %r15, %r13
movl %ebp, %r15d
movq %rcx, %r12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x11acf3
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x11af23
movq %rbx, %rdi
movl %r14d, %esi
callq 0x11b054
movq %rbx, %rdi
leaq 0x29ecd0(%rip), %rsi    # 0x353eef
callq 0x11acf3
movq %rbx, %rdi
callq 0x11b0a1
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq 0x70(%rsp), %r8
callq 0x1cc8a8
movl %eax, %ebp
movq %rbx, %rdi
callq 0x11b132
incl %r14d
cmpl %r14d, %r15d
jne 0xb51f2
jmp 0xb525c
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x11bdbf
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_assembly.c
// Function: gt_readjoiner_assembly_arguments_new
static void* gt_readjoiner_assembly_arguments_new(void)
{
  GtReadjoinerAssemblyArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->buffersizearg = gt_str_new();
  arguments->buffersize = 0UL; /* in bytes */
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x29d631(%rip), %rdx    # 0x3528d9
movl $0x1, %edi
movl $0x58, %esi
movl $0x33, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
movq $0x0, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_assembly.c
// Function: gt_readjoiner_assembly_arguments_delete
static void gt_readjoiner_assembly_arguments_delete(void *tool_arguments)
{
  GtReadjoinerAssemblyArguments *arguments = tool_arguments;
  if (!arguments)
    return;
  gt_str_delete(arguments->readset);
  gt_str_delete(arguments->buffersizearg);
  gt_option_delete(arguments->refoptionbuffersize);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xb5317
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x10a16a
leaq 0x29d5d0(%rip), %rsi    # 0x3528d9
movq %rbx, %rdi
movl $0x42, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_assembly.c
// Function: gt_readjoiner_assembly_arguments_check
static int gt_readjoiner_assembly_arguments_check(GT_UNUSED int rest_argc,
    void *tool_arguments, GtError *err)
{
  GtReadjoinerAssemblyArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  if (had_err == 0 && gt_option_is_set(arguments->refoptionbuffersize))
    if (gt_option_parse_spacespec(&arguments->buffersize,
          "buffersize", arguments->buffersizearg, err) != 0)
      had_err = -1;
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xb57b0
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xb57eb
movq 0x38(%r14), %rdi
callq 0x10ac3f
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xb57e3
movq 0x18(%r14), %rdx
addq $0x40, %r14
leaq 0x2f7a39(%rip), %rsi    # 0x3ad209
movq %r14, %rdi
movq %rbx, %rcx
callq 0x10ac4e
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1d689
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_cgraph.c
// Function: gt_readjoiner_cgraph_arguments_new
static void* gt_readjoiner_cgraph_arguments_new(void)
{
  GtReadjoinerCgraphArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->subgraph = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x29ca76(%rip), %rdx    # 0x35316d
movl $0x1, %edi
movl $0x20, %esi
movl $0x29, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11be10
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_cgraph.c
// Function: gt_readjoiner_cgraph_arguments_delete
static void gt_readjoiner_cgraph_arguments_delete(void *tool_arguments)
{
  GtReadjoinerCgraphArguments *arguments = tool_arguments;
  if (!arguments)
    return;
  gt_str_delete(arguments->readset);
  gt_str_array_delete(arguments->subgraph);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xb6755
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11c144
leaq 0x29ca26(%rip), %rsi    # 0x35316d
movq %rbx, %rdi
movl $0x36, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_cnttest.c
// Function: gt_readjoiner_cnttest_arguments_new
static void* gt_readjoiner_cnttest_arguments_new(void)
{
  GtReadjoinerCnttestArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->teststr = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x29c53c(%rip), %rdx    # 0x3533ac
movl $0x1, %edi
movl $0x18, %esi
movl $0x30, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_cnttest.c
// Function: gt_readjoiner_cnttest_arguments_delete
static void gt_readjoiner_cnttest_arguments_delete(void *tool_arguments)
{
  GtReadjoinerCnttestArguments *arguments = tool_arguments;
  if (arguments == NULL)
    return;
  gt_str_delete(arguments->readset);
  gt_str_delete(arguments->teststr);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xb6ecc
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
leaq 0x29c4ee(%rip), %rsi    # 0x3533ac
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_cnttest.c
// Function: gt_readjoiner_cnttest_option_parser_new
static GtOptionParser* gt_readjoiner_cnttest_option_parser_new(
    void *tool_arguments)
{
  GtReadjoinerCnttestArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("-readset [option ...]",
      "Test/development tool for readjoiner containments filtering.");

  /* -readset */
  option = gt_option_new_string("readset", "specify the readset name",
      arguments->readset, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  /* -test */
  option = gt_option_new_string("test",
      "select among the available tests:\n"
      "showlist: show content of an cnt list (input: cntlist)\n"
      "bruteforce: memcmp reads vs all suffixes and prefixes (input: encseq)\n"
      "kmp: variant of Knuth-Morris-Pratt (input: encseq)\n"
      "esa: own esa-based algorithm (input: esa)",
      arguments->teststr, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  /* -singlestrand */
  option = gt_option_new_bool("singlestrand", "do not use reads "
      "reverse complements", &arguments->singlestrand, false);
  gt_option_parser_add_option(op, option);

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

  gt_option_parser_set_version_func(op, gt_readjoiner_show_version);
  gt_option_parser_set_max_args(op, 0);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xb6fae
movq %rdi, %r14
leaq 0x29c511(%rip), %rdi    # 0x3533f6
leaq 0x29c520(%rip), %rsi    # 0x35340c
callq 0x107bfe
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x29b736(%rip), %rdi    # 0x352634
leaq 0x29b737(%rip), %rsi    # 0x35263c
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a87b
movq 0x8(%r14), %rdx
leaq 0x290ab6(%rip), %rdi    # 0x3479e3
leaq 0x29c515(%rip), %rsi    # 0x353449
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a87b
leaq 0x14(%r14), %rdx
leaq 0x293861(%rip), %rdi    # 0x34a7bd
leaq 0x29c5e2(%rip), %rsi    # 0x353545
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
addq $0x15, %r14
movq %r14, %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x123fbd(%rip), %rsi    # 0x1daf50
movq %rbx, %rdi
callq 0x107d51
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10873c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d888
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_cnttest.c
// Function: gt_readjoiner_cnttest_arguments_check
static int gt_readjoiner_cnttest_arguments_check(GT_UNUSED int rest_argc,
    void *tool_arguments, GT_UNUSED GtError *err)
{
  GtReadjoinerCnttestArguments *arguments = tool_arguments;
  const char *teststr = gt_str_get(arguments->teststr);
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  if (strcmp(teststr, "showlist") == 0)
    arguments->test = GT_READJOINER_CNTTEST_SHOWLIST;
  else if (strcmp(teststr, "bruteforce") == 0)
    arguments->test = GT_READJOINER_CNTTEST_BRUTEFORCE;
  else if (strcmp(teststr, "kmp") == 0)
    arguments->test = GT_READJOINER_CNTTEST_KMP;
  else if (strcmp(teststr, "esa") == 0)
    arguments->test = GT_READJOINER_CNTTEST_ESA;
  else
  {
    gt_error_set(err, "illegal argument \"%s\" to option -test", teststr);
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rdi
callq 0x11b0a1
movq %rax, %r15
testq %rbx, %rbx
je 0xb6fdf
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xb7074
leaq 0x29c5aa(%rip), %rsi    # 0x353590
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xb7046
leaq 0x2b0c10(%rip), %rsi    # 0x367c09
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xb7050
leaq 0x32e34d(%rip), %rsi    # 0x3e5359
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xb705a
leaq 0x2a2c06(%rip), %rsi    # 0x359c25
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xb7064
leaq 0x29c567(%rip), %rsi    # 0x353599
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xb706e
movl $0x0, 0x10(%r14)
jmp 0xb706c
movl $0x1, 0x10(%r14)
jmp 0xb706c
movl $0x2, 0x10(%r14)
jmp 0xb706c
movl $0x3, 0x10(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d8bf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_correct.c
// Function: gt_readjoiner_correct_option_parser_new
static GtOptionParser* gt_readjoiner_correct_option_parser_new(
    void *tool_arguments)
{
  GtReadjoinerCorrectArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[options] -ii indexname",
      "Readjoiner k-mer based error correction.");

  option = gt_option_new_uword_min("k","k-mer length",
                                  &arguments->k, 31UL, 1UL);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword_min("c","minimal trusted count",
                                  &arguments->c, 3UL, 1UL);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("encseq","correct encoded sequence",
      &arguments->edit_twobitencoding, true);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_string("ii", "input index",
                                arguments->indexname, NULL);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_uword("dbg","(debug value) "
      "see code for current meaning", &arguments->debug_value, GT_UNDEF_UWORD);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  gt_option_parser_set_version_func(op, gt_readjoiner_show_version);
  gt_option_parser_set_max_args(op, 0);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xb752e
movq %rdi, %r14
leaq 0x29ae92(%rip), %rdi    # 0x35229e
leaq 0x29c213(%rip), %rsi    # 0x353626
callq 0x107bfe
movq %rax, %rbx
leaq 0x2935fe(%rip), %rdi    # 0x34aa20
leaq 0x29c226(%rip), %rsi    # 0x35364f
movl $0x1f, %ecx
movl $0x1, %r8d
movq %r14, %rdx
callq 0x10a5d1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x8(%r14), %rdx
leaq 0x30cde6(%rip), %rdi    # 0x3c4238
leaq 0x29c203(%rip), %rsi    # 0x35365c
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x10a5d1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x20(%r14), %rdx
leaq 0x2cfd7e(%rip), %rdi    # 0x3871fd
leaq 0x29c1ec(%rip), %rsi    # 0x353672
movl $0x1, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x10(%r14), %rdx
leaq 0x2fbfc2(%rip), %rdi    # 0x3b3473
leaq 0x29aed2(%rip), %rsi    # 0x35238a
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10a87b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
addq $0x18, %r14
leaq 0x29c1ab(%rip), %rdi    # 0x35368b
leaq 0x29c1a8(%rip), %rsi    # 0x35368f
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x10a2ab
movq %rax, %r14
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x107cc0
leaq 0x123a3d(%rip), %rsi    # 0x1daf50
movq %rbx, %rdi
callq 0x107d51
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10873c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d9a1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_correct.c
// Function: gt_readjoiner_correct_runner
static int gt_readjoiner_correct_runner(GT_UNUSED int argc,
    GT_UNUSED const char **argv, GT_UNUSED int parsed_args,
    void *tool_arguments, GT_UNUSED GtError *err)
{
  GtReadjoinerCorrectArguments *arguments = tool_arguments;
  Sequentialsuffixarrayreader *ssar;
  GtLogger *logger;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);
  logger = gt_logger_new(true, GT_LOGGER_DEFLT_PREFIX, stderr);

  ssar = gt_newSequentialsuffixarrayreaderfromfile(
      gt_str_get(arguments->indexname), SARR_LCPTAB | SARR_SUFTAB |
      SARR_ESQTAB | SARR_SSPTAB, true, logger, err);
  if (ssar == NULL)
    had_err = -1;
  else
  {
    GtStr *indexname_corrected = gt_str_clone(arguments->indexname);
    gt_str_append_cstr(arguments->indexname, GT_READJOINER_CORRECT_TAG);
    had_err = gt_errfind(ssar, gt_encseqSequentialsuffixarrayreader(ssar),
           arguments->k, arguments->c, arguments->debug_value,
           arguments->edit_twobitencoding, gt_str_get(indexname_corrected),
           err);
    gt_freeSequentialsuffixarrayreader(&ssar);
    gt_str_delete(indexname_corrected);
  }
  gt_logger_delete(logger);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, %r15
testq %r8, %r8
je 0xb755c
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xb7665
movq 0x401a1d(%rip), %rax    # 0x4b8f80
movq (%rax), %rdx
testq %r15, %r15
je 0xb765d
leaq 0x28f35e(%rip), %rsi    # 0x3468d4
movl $0x1, %edi
callq 0x103e40
movq %rax, %r14
movq 0x10(%r15), %rdi
callq 0x11b0a1
movq %rax, %rdi
movl $0x87, %esi
movl $0x1, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1a5580
movq %rax, 0x20(%rsp)
testq %rax, %rax
je 0xb763f
movq %rax, %r13
movq 0x10(%r15), %rdi
callq 0x11b191
movq %rax, %r12
movq 0x10(%r15), %rdi
leaq 0x29c10b(%rip), %rsi    # 0x3536d7
callq 0x11acf3
movq %r13, %rdi
callq 0x1a59f6
movq %rax, %rbp
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq 0x8(%r15), %r14
movq 0x18(%r15), %rax
movq %rax, 0x8(%rsp)
movzbl 0x20(%r15), %r15d
movq %r12, %rdi
callq 0x11b0a1
movq %r13, %rdi
movq %rbp, %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
movq 0x18(%rsp), %r14
movq 0x8(%rsp), %r8
movl %r15d, %r9d
pushq %rbx
pushq %rax
callq 0x1c882c
addq $0x10, %rsp
movl %eax, %ebx
leaq 0x20(%rsp), %rdi
callq 0x1a5698
movq %r12, %rdi
callq 0x11bdbf
jmp 0xb7644
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x1040e0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rdi
callq 0x1da0f
callq 0x1d9d8
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_graph.c
// Function: gt_readjoiner_graph_arguments_new
static void* gt_readjoiner_graph_arguments_new(void)
{
  GtReadjoinerGraphArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->subgraph = gt_str_array_new();
  arguments->subgraph_other = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x29b2e5(%rip), %rdx    # 0x353870
movl $0x1, %edi
movl $0x60, %esi
movl $0x2e, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11be10
movq %rax, 0x28(%rbx)
callq 0x11be10
movq %rax, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_graph.c
// Function: gt_readjoiner_graph_arguments_delete
static void gt_readjoiner_graph_arguments_delete(void *tool_arguments)
{
  GtReadjoinerGraphArguments *arguments = tool_arguments;
  if (!arguments)
    return;
  gt_str_delete(arguments->readset);
  gt_str_array_delete(arguments->subgraph);
  gt_str_array_delete(arguments->subgraph_other);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xb85f9
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11bdbf
movq 0x28(%rbx), %rdi
callq 0x11c144
movq 0x30(%rbx), %rdi
callq 0x11c144
leaq 0x29b285(%rip), %rsi    # 0x353870
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_overlap.c
// Function: gt_readjoiner_overlap_arguments_new
static void* gt_readjoiner_overlap_arguments_new(void)
{
  GtReadjoinerOverlapArguments *arguments = gt_calloc((size_t) 1,
      sizeof *arguments);
  arguments->encseqinput = gt_str_new();
  arguments->numofparts = 0;
  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 0x29a80b(%rip), %rdx    # 0x353fbf
movl $0x1, %edi
movl $0x60, %esi
movl $0x3b, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x28(%rbx)
movl $0x0, 0xc(%rbx)
callq 0x11ac6c
movq %rax, 0x30(%rbx)
callq 0x11ac6c
movq %rax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_overlap.c
// Function: gt_readjoiner_overlap_arguments_delete
static void gt_readjoiner_overlap_arguments_delete(void *tool_arguments)
{
  GtReadjoinerOverlapArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->encseqinput);
  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 0xb9844
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x11bdbf
movq 0x40(%rbx), %rdi
callq 0x10a16a
movq 0x48(%rbx), %rdi
callq 0x10a16a
movq 0x30(%rbx), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x11bdbf
leaq 0x29a789(%rip), %rsi    # 0x353fbf
movq %rbx, %rdi
movl $0x4e, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_overlap.c
// Function: gt_readjoiner_overlap_arguments_check
static int gt_readjoiner_overlap_arguments_check(int rest_argc,
                                         void *tool_arguments,
                                         GtError *err)
{
  GtReadjoinerOverlapArguments *arguments = tool_arguments;
  bool haserr = false;

  gt_error_check(err);
  if (rest_argc != 0)
  {
    gt_error_set(err,"unnecessary arguments");
    haserr = true;
  }
  if (!haserr && gt_option_is_set(arguments->refoptionmemlimit))
  {
    if (gt_option_parse_spacespec(&arguments->maximumspace,
          "memlimit",
          arguments->memlimitarg,
          err) != 0)
    {
      haserr = true;
    }
  }
  if (!haserr && gt_option_is_set(arguments->refoptionphase2extra))
  {
    if (gt_option_parse_spacespec(&arguments->phase2extra,
          "phase2extra",
          arguments->phase2extraarg,
          err) != 0)
    {
      haserr = true;
    }
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0xb9b54
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xb9bd7
testl %ebp, %ebp
je 0xb9b73
leaq 0x290ee1(%rip), %rsi    # 0x34aa40
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
movq 0x40(%r14), %rdi
callq 0x10ac3f
testb %al, %al
je 0xb9ba2
leaq 0x18(%r14), %rdi
movq 0x30(%r14), %rdx
leaq 0x32afb9(%rip), %rsi    # 0x3e4b48
movq %rbx, %rcx
callq 0x10ac4e
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0xb9b6e
movq 0x48(%r14), %rdi
callq 0x10ac3f
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xb9b6e
movq 0x38(%r14), %rdx
addq $0x20, %r14
leaq 0x290cc2(%rip), %rsi    # 0x34a884
movq %r14, %rdi
movq %rbx, %rcx
callq 0x10ac4e
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0xb9b6e
callq 0x1dca9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_prefilter.c
// Function: gt_readjoiner_prefilter_arguments_new
static void* gt_readjoiner_prefilter_arguments_new(void)
{
  GtReadjoinerPrefilterArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->db = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x29a17d(%rip), %rdx    # 0x3542bc
movl $0x1, %edi
movl $0x48, %esi
movl $0x31, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11be10
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_prefilter.c
// Function: gt_readjoiner_prefilter_arguments_delete
static void gt_readjoiner_prefilter_arguments_delete(void *tool_arguments)
{
  GtReadjoinerPrefilterArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->readset);
  gt_str_array_delete(arguments->db);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xba19d
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11c144
leaq 0x29a12d(%rip), %rsi    # 0x3542bc
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_spmtest.c
// Function: gt_readjoiner_spmtest_arguments_new
static void* gt_readjoiner_spmtest_arguments_new(void)
{
  GtReadjoinerSpmtestArguments *arguments = gt_calloc((size_t)1,
      sizeof *arguments);
  arguments->readset = gt_str_new();
  arguments->teststr = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x299b09(%rip), %rdx    # 0x354b4d
movl $0x1, %edi
movl $0x20, %esi
movl $0x30, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_spmtest.c
// Function: gt_readjoiner_spmtest_arguments_delete
static void gt_readjoiner_spmtest_arguments_delete(void *tool_arguments)
{
  GtReadjoinerSpmtestArguments *arguments = tool_arguments;
  if (arguments == NULL)
    return;
  gt_str_delete(arguments->readset);
  gt_str_delete(arguments->teststr);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xbb0a0
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
leaq 0x299abb(%rip), %rsi    # 0x354b4d
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_spmtest.c
// Function: gt_readjoiner_spmtest_option_parser_new
static GtOptionParser* gt_readjoiner_spmtest_option_parser_new(
    void *tool_arguments)
{
  GtReadjoinerSpmtestArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("-readset [option ...]",
      "Test/development tool for readjoiner overlap phase.");

  /* -readset */
  option = gt_option_new_string("readset", "specify the readset name",
      arguments->readset, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  /* -l */
  option = gt_option_new_uint_min("l", "specify the minimum spm length",
      &arguments->minmatchlength, 0, 1U);
  gt_option_parser_add_option(op, option);

  /* -test */
  option = gt_option_new_string("test",
      "select among the available tests:\n"
      "showlist: show content of an spm list (input: spmlist)\n"
      "bruteforce: memcmp all suffixes and prefixes (input: encseq)\n"
      "kmp: variant of Knuth-Morris-Pratt (input: encseq)\n"
      "gusfield: Gusfield all pairs suffix-prefix (input: esa)",
      arguments->teststr, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  /* -singlestrand */
  option = gt_option_new_bool("singlestrand", "do not use reads "
      "reverse complements", &arguments->singlestrand, false);
  gt_option_parser_add_option(op, option);

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

  gt_option_parser_set_version_func(op, gt_readjoiner_show_version);
  gt_option_parser_set_max_args(op, 0);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbb1ac
movq %rdi, %r14
leaq 0x29833d(%rip), %rdi    # 0x3533f6
leaq 0x299ad7(%rip), %rsi    # 0x354b97
callq 0x107bfe
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x297562(%rip), %rdi    # 0x352634
leaq 0x297563(%rip), %rsi    # 0x35263c
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a87b
leaq 0x14(%r14), %rdx
leaq 0x2cca7c(%rip), %rdi    # 0x387b7d
leaq 0x299ac3(%rip), %rsi    # 0x354bcb
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10a51f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x8(%r14), %rdx
leaq 0x28c8b8(%rip), %rdi    # 0x3479e3
leaq 0x299ab8(%rip), %rsi    # 0x354bea
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a87b
leaq 0x18(%r14), %rdx
leaq 0x28f663(%rip), %rdi    # 0x34a7bd
leaq 0x2983e4(%rip), %rsi    # 0x353545
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
addq $0x19, %r14
movq %r14, %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x11fdbf(%rip), %rsi    # 0x1daf50
movq %rbx, %rdi
callq 0x107d51
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10873c
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1dd8b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readjoiner_spmtest.c
// Function: gt_readjoiner_spmtest_arguments_check
static int gt_readjoiner_spmtest_arguments_check(GT_UNUSED int rest_argc,
    void *tool_arguments, GT_UNUSED GtError *err)
{
  GtReadjoinerSpmtestArguments *arguments = tool_arguments;
  const char *teststr = gt_str_get(arguments->teststr);
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  if (strcmp(teststr, "showlist") == 0)
    arguments->test = GT_READJOINER_SPMTEST_SHOWLIST;
  else if (strcmp(teststr, "bruteforce") == 0)
    arguments->test = GT_READJOINER_SPMTEST_BRUTEFORCE;
  else if (strcmp(teststr, "kmp") == 0)
    arguments->test = GT_READJOINER_SPMTEST_KMP;
  else if (strcmp(teststr, "gusfield") == 0)
    arguments->test = GT_READJOINER_SPMTEST_GUSFIELD;
  else
  {
    gt_error_set(err, "illegal argument \"%s\" to option -test", teststr);
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rsi), %rdi
callq 0x11b0a1
movq %rax, %r15
testq %rbx, %rbx
je 0xbb1dd
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xbb272
leaq 0x2983ac(%rip), %rsi    # 0x353590
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xbb244
leaq 0x2aca12(%rip), %rsi    # 0x367c09
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xbb24e
leaq 0x32a14f(%rip), %rsi    # 0x3e5359
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xbb258
leaq 0x2f2f20(%rip), %rsi    # 0x3ae13d
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xbb262
leaq 0x298369(%rip), %rsi    # 0x353599
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xbb26c
movl $0x0, 0x10(%r14)
jmp 0xbb26a
movl $0x1, 0x10(%r14)
jmp 0xbb26a
movl $0x2, 0x10(%r14)
jmp 0xbb26a
movl $0x3, 0x10(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1ddc2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_readreads.c
// Function: gt_readreads_arguments_check
static int gt_readreads_arguments_check(GT_UNUSED int rest_argc,
                                        GT_UNUSED void *tool_arguments,
                                        GT_UNUSED GtError *err)
{
  GT_UNUSED GtReadreads *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  return had_err;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0xbb6f1
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xbb6ff
testq %rbx, %rbx
je 0xbb6fa
xorl %eax, %eax
popq %rbx
retq
callq 0x1df12
callq 0x1dedb