LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_mmapandread.c
// Function: gt_mmapandread_runner
static int gt_mmapandread_runner(int argc, const char **argv, int parsed_args,
                                 GT_UNUSED void *tool_arguments,
                                 GT_UNUSED GtError *err)
{
  int i, fd;
  void *map;
  struct stat sb;
  GtUint64 j;
  unsigned int byte = 0;
  gt_error_check(err);

  /* iterate over all files */
  for (i = parsed_args; i < argc; i++) {
    /* open file */
    fd = gt_xopen(argv[i], O_RDONLY, 0);

    /* get file statistics */
    gt_xfstat(fd, &sb);

    if (sb.st_size == 0)
      printf("file \"%s\" is empty\n", argv[i]);
    else if (!(sb.st_mode & S_IFREG))
      printf("\"%s\" is not a regular file\n", argv[i]);
    else {
      /* map file */
#ifndef _WIN32
      map = gt_xmmap(0, sb.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
#else
      /* XXX */
      fprintf(stderr, "mmapandread not implemented\n");
      exit(EXIT_FAILURE);
#endif

      /* read file */
      printf("reading file \"%s\"\n", argv[i]);
      j = 0;
      gt_progressbar_start(&j, (GtUint64) sb.st_size);
      for (; j < (GtUint64) sb.st_size; j++)
        byte |= (unsigned int) ((char*) map)[j];
      gt_progressbar_stop();

      /* unmap file */
#ifndef _WIN32
      gt_xmunmap(map, sb.st_size);
#else
      /* XXX */
#endif
    }

    /* close file */
    gt_xclose(fd);
  }

  if (!byte)
    printf("all read files contained only null characters\n");

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movl %edi, %ebp
testq %r8, %r8
je 0xb3728
movq %r8, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb385b
cmpl %ebp, %r14d
jge 0xb383b
movslq %r14d, %r15
leaq 0x18(%rsp), %r12
xorl %r14d, %r14d
movl %ebp, 0x14(%rsp)
movq (%rbx,%r15,8), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x125941
movl %eax, %r13d
movl %eax, %edi
movq %r12, %rsi
callq 0x1258d7
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0xb3778
testb $-0x80, 0x31(%rsp)
jne 0xb378f
movq (%rbx,%r15,8), %rsi
leaq 0x2a6a8b(%rip), %rdi    # 0x35a201
jmp 0xb3783
movq (%rbx,%r15,8), %rsi
leaq 0x2a6a6a(%rip), %rdi    # 0x35a1ed
xorl %eax, %eax
callq 0x17070
jmp 0xb3822
movq %r12, %rbp
xorl %edi, %edi
movl $0x1, %edx
movl $0x2, %ecx
movl %r13d, %r8d
xorl %r9d, %r9d
callq 0x125989
movq %rax, %r12
movq (%rbx,%r15,8), %rsi
leaq 0x2a6a66(%rip), %rdi    # 0x35a21d
xorl %eax, %eax
callq 0x17070
movq $0x0, 0x8(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x110c6c
movq 0x48(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq %rax, %rcx
jae 0xb3809
incq %rcx
negq %rax
movsbl -0x1(%r12,%rcx), %edx
orl %edx, %r14d
movq %rcx, 0x8(%rsp)
leaq (%rax,%rcx), %rdx
incq %rdx
incq %rcx
cmpq $0x1, %rdx
jne 0xb37eb
callq 0x111189
movq 0x48(%rsp), %rsi
movq %r12, %rdi
callq 0x12599c
movq %rbp, %r12
movl 0x14(%rsp), %ebp
movl %r13d, %edi
callq 0x1258b4
incq %r15
cmpl %ebp, %r15d
jne 0xb3740
testl %r14d, %r14d
jne 0xb3847
leaq 0x2a69ee(%rip), %rdi    # 0x35a230
callq 0x17bd0
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1ccfc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_orffinder.c
// Function: gt_orffinder_arguments_new
static void* gt_orffinder_arguments_new(void)
{
  GtOrffinderArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->ofi = gt_output_file_info_new();
  arguments->types = gt_str_array_new();
  arguments->s2fi = gt_seqid2file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a69ce(%rip), %rdx    # 0x35a25e
movl $0x1, %edi
movl $0x30, %esi
movl $0x38, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x10ff7c
movq %rax, 0x18(%rbx)
callq 0x121b54
movq %rax, 0x10(%rbx)
callq 0x17b020
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_orffinder.c
// Function: gt_orffinder_arguments_delete
static void gt_orffinder_arguments_delete(void *tool_arguments)
{
  GtOrffinderArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_array_delete(arguments->types);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xb3908
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x1040fc
movq 0x18(%rbx), %rdi
callq 0x110231
movq 0x10(%rbx), %rdi
callq 0x121e8b
movq 0x28(%rbx), %rdi
callq 0x17b067
leaq 0x2a6964(%rip), %rsi    # 0x35a25e
movq %rbx, %rdi
movl $0x47, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_orffinder.c
// Function: gt_orffinder_arguments_check
static int gt_orffinder_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments, GtError *err)
{
  GtOrffinderArguments *arguments = tool_arguments;
  int had_err = 0;
  int diff;

  gt_error_check(err);
  gt_assert(arguments);

  diff = (arguments->max - arguments->min);
  if (diff < 0) {
    gt_error_set(err, "Value for -min must be larger than -max");
    had_err = -1;
  }

  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0xb3a2d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb3a61
testq %r14, %r14
je 0xb3a5c
movl 0xc(%r14), %ecx
xorl %eax, %eax
cmpl 0x8(%r14), %ecx
jns 0xb3a54
leaq 0x2a698c(%rip), %rsi    # 0x35a3d1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1cda3
callq 0x1cd6a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_packedindex.c
// Function: gt_packedindex_arguments_new
static void* gt_packedindex_arguments_new(void)
{
  GtToolbox *packedindex_toolbox = gt_toolbox_new();
  gt_toolbox_add(packedindex_toolbox, "mkindex", gt_packedindex_make);
  gt_toolbox_add(packedindex_toolbox, "mkctxmap", gt_packedindex_mkctxmap);
  gt_toolbox_add(packedindex_toolbox, "trsuftab", gt_packedindex_trsuftab);
  gt_toolbox_add(packedindex_toolbox, "chkintegrity",
              gt_packedindex_chk_integrity );
  gt_toolbox_add(packedindex_toolbox, "chksearch", gt_packedindex_chk_search);
  return packedindex_toolbox;
}

// Assembly:
pushq %rbx
callq 0x12391a
movq %rax, %rbx
leaq 0x2a66f2(%rip), %rsi    # 0x35a431
leaq 0x1d8(%rip), %rdx       # 0xb3f1e
movq %rax, %rdi
callq 0x123a37
leaq 0x2a6fec(%rip), %rsi    # 0x35ad41
leaq 0xc88(%rip), %rdx       # 0xb49e4
movq %rbx, %rdi
callq 0x123a37
leaq 0x2a70d6(%rip), %rsi    # 0x35ae41
leaq 0xfa6(%rip), %rdx       # 0xb4d18
movq %rbx, %rdi
callq 0x123a37
leaq 0x2a66b8(%rip), %rsi    # 0x35a439
leaq 0x1a8(%rip), %rdx       # 0xb3f30
movq %rbx, %rdi
callq 0x123a37
leaq 0x2a66af(%rip), %rsi    # 0x35a446
leaq 0x3de(%rip), %rdx       # 0xb417c
movq %rbx, %rdi
callq 0x123a37
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_packedindex.c
// Function: gt_packedindex_option_parser_new
static GtOptionParser* gt_packedindex_option_parser_new(void *tool_arguments)
{
  GtToolbox *index_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(index_toolbox);
  op = gt_option_parser_new("[option ...] index_tool [argument ...]",
                         "Call apacked index subtool and pass argument(s) to "
                         "it.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, index_toolbox);
  gt_option_parser_set_min_args(op, 1);
  gt_option_parser_refer_to_manual(op);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb3e09
movq %rdi, %rbx
leaq 0x2a66d2(%rip), %rdi    # 0x35a49a
leaq 0x2a66f2(%rip), %rsi    # 0x35a4c1
callq 0x10cc4e
movq %rax, %r14
leaq 0x6fcd0(%rip), %rsi     # 0x123aae
movq %rax, %rdi
movq %rbx, %rdx
callq 0x10cd8d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10d766
movq %r14, %rdi
callq 0x10cd7d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1ce87
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_packedindex.c
// Function: gt_packedindex_runner
static int gt_packedindex_runner(int argc, const char **argv, int parsed_args,
                                 void *tool_arguments, GtError *err)
{
  GtToolbox *index_toolbox = tool_arguments;
  GtToolfunc toolfunc;
  GtTool *tool = NULL;
  char **nargv = NULL;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(index_toolbox);

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

  /* call sub-tool */
  if (!had_err) {
    if (!(toolfunc = gt_toolbox_get(index_toolbox, argv[parsed_args]))) {
      tool = gt_toolbox_get_tool(index_toolbox, argv[parsed_args]);
      gt_assert(tool);
    }
    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);
  }

  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 0xb3e3c
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb3f14
testq %r15, %r15
je 0xb3f0f
movslq %r14d, %r13
movq (%r12,%r13,8), %rsi
movq %r15, %rdi
callq 0x123a17
movq (%r12,%r13,8), %rdx
testb %al, %al
je 0xb3e7d
leaq (%r12,%r13,8), %r13
movq %r15, %rdi
movq %rdx, %rsi
callq 0x123a87
movq %rax, %r12
testq %rax, %rax
je 0xb3e98
movq $0x0, (%rsp)
jmp 0xb3ead
leaq 0x2a668a(%rip), %rsi    # 0x35a50e
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xb3ef6
movq (%r13), %rsi
movq %r15, %rdi
callq 0x1239f1
movq %rax, (%rsp)
testq %rax, %rax
je 0xb3f19
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 0xb3ee3
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r12
jmp 0xb3ef4
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 0x1cf2c
callq 0x1cebe
callq 0x1cef5
// File: /workspace/github_c_makefile_star2_O1/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 0xb58e3
movq %rcx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb58f8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x121c30
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1d460
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xb59b6
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb5a2f
movslq %ebp, %rax
movq (%r14,%rax,8), %rdi
movq %rbx, %rsi
callq 0x18d70c
movq %rax, %rbx
testq %rax, %rax
je 0xb5a12
movq %rbx, %rdi
callq 0x18dfc3
testq %rax, %rax
je 0xb5a12
xorl %r14d, %r14d
leaq 0x2a58b9(%rip), %r15    # 0x35b29d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x18dfab
movq %rax, %rdi
movq %r15, %rsi
callq 0x18d6c1
movq %rax, %rdi
callq 0x17bd0
incq %r14
movq %rbx, %rdi
callq 0x18dfc3
cmpq %rax, %r14
jb 0xb59e4
xorl %ebp, %ebp
cmpq $0x1, %rbx
sbbl %ebp, %ebp
movq %rbx, %rdi
callq 0x18df26
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1d4d0
// File: /workspace/github_c_makefile_star2_O1/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 0xb61be
movq %rdi, %rbx
callq 0x1208f8
movq %rax, (%rbx)
leaq 0x2a537f(%rip), %rdi    # 0x35b4bb
leaq 0x2a5391(%rip), %rsi    # 0x35b4d4
callq 0x10cc4e
movq %rax, %r14
leaq 0x29917a(%rip), %rsi    # 0x34f2cc
movq %rax, %rdi
callq 0x10ceab
movq (%rbx), %rdx
leaq 0x2a067a(%rip), %rdi    # 0x3567de
leaq 0x29cbc1(%rip), %rsi    # 0x352d2c
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fa96
addq $0x8, %rbx
leaq 0x2baba0(%rip), %rdi    # 0x370d33
leaq 0x2a5368(%rip), %rsi    # 0x35b502
movq %rbx, %rdx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10f73b
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1d693
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq %rcx, %r12
movq (%rcx), %rdi
callq 0x120d23
movq %rax, %r15
movq %rax, %rdi
movq %rbx, (%rsp)
movq %rbx, %rsi
callq 0x1000e4
movq %rax, %rbx
xorl %r13d, %r13d
testq %rax, %rax
sete %r14b
je 0xb621a
movq %rbx, %rdi
callq 0x100d2c
movq %rax, %rbp
testq %rax, %rax
movb %r14b, %r13b
movl $0x1, %r14d
cmovnel %r13d, %r14d
jmp 0xb621a
testb %r14b, %r14b
je 0xb6224
xorl %r13d, %r13d
jmp 0xb6246
movq %r15, %rdi
xorl %esi, %esi
movq (%rsp), %rdx
callq 0x1a86aa
movq %rax, %r13
testq %rax, %rax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovnel %eax, %r14d
testb %r14b, %r14b
jne 0xb6299
movq %rbp, %rdi
callq 0xd3713
movl %eax, %ebp
movq %r13, %rdi
callq 0x1a8e11
movl 0x8(%r12), %ecx
movq %r13, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x1c0c96
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq (%rsp), %rdx
callq 0x1c1195
testl %eax, %eax
movzbl %r14b, %eax
movl $0x1, %r14d
cmovel %eax, %r14d
movq %r12, %rdi
callq 0x1c0c0c
movq %rbx, %rdi
callq 0x100e07
testq %r13, %r13
je 0xb62ae
movq %r13, %rdi
callq 0x1a87ef
movzbl %r14b, %eax
negl %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x12391a
movq %rax, %rbx
callq 0xbc18c
leaq 0x2a5208(%rip), %rsi    # 0x35b524
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xbb7c4
leaq 0x2c1fd7(%rip), %rsi    # 0x37830a
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xb7370
leaq 0x2a51e4(%rip), %rsi    # 0x35b52e
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12394f
callq 0xb6560
leaq 0x2a5455(%rip), %rsi    # 0x35b7b6
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12399e
callq 0xb979c
leaq 0x2a64a0(%rip), %rsi    # 0x35c818
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12399e
callq 0xba61c
leaq 0x302fd6(%rip), %rsi    # 0x3b9365
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12399e
callq 0xb87a8
leaq 0x2a5fd8(%rip), %rsi    # 0x35c37e
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12399e
callq 0xb8f54
leaq 0x2a517a(%rip), %rsi    # 0x35b537
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12399e
callq 0xbd084
leaq 0x2a516b(%rip), %rsi    # 0x35b53f
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12399e
callq 0xb94a8
leaq 0x31e551(%rip), %rsi    # 0x3d493c
movq %rbx, %rdi
movq %rax, %rdx
callq 0x12399e
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2996e5(%rip), %rdi    # 0x34faf2
leaq 0x2a5133(%rip), %rsi    # 0x35b547
callq 0x10cc4e
movq %rax, %rbx
leaq 0x12e355(%rip), %rsi    # 0x1e4778
movq %rax, %rdi
callq 0x10cda1
leaq 0x9da6a(%rip), %rsi     # 0x153e9c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10cd8d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10d766
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb647c
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb6554
testq %r15, %r15
je 0xb654f
movslq %r14d, %r13
movq (%r12,%r13,8), %rsi
movq %r15, %rdi
callq 0x123a17
movq (%r12,%r13,8), %rdx
testb %al, %al
je 0xb64bd
leaq (%r12,%r13,8), %r13
movq %r15, %rdi
movq %rdx, %rsi
callq 0x123a87
movq %rax, %r12
testq %rax, %rax
je 0xb64d8
movq $0x0, (%rsp)
jmp 0xb64ed
leaq 0x2a50fa(%rip), %rsi    # 0x35b5be
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xb6536
movq (%r13), %rsi
movq %r15, %rdi
callq 0x1239f1
movq %rax, (%rsp)
testq %rax, %rax
je 0xb6559
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 0xb6523
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r12
jmp 0xb6534
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 0x1d738
callq 0x1d6ca
callq 0x1d701
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1208f8
movq %rbx, %rcx
movq %rax, %rbx
testq %r12, %r12
je 0xb72b8
movq %r12, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
testl %ebp, %ebp
je 0xb7355
testq %r12, %r12
movl %r13d, %eax
movq %rax, 0x10(%rsp)
cmovneq 0x40cc65(%rip), %rcx    # 0x4c3f38
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 0x12097f
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x120ba5
movq %rbx, %rdi
movl %r14d, %esi
callq 0x120cd6
movq %rbx, %rdi
leaq 0x2a5c0d(%rip), %rsi    # 0x35cf27
callq 0x12097f
movq %rbx, %rdi
callq 0x120d23
movq %rax, %rdi
movq 0x10(%rsp), %rsi
movq %r12, %rdx
movq 0x8(%rsp), %rcx
movq 0x70(%rsp), %r8
callq 0x1d5b40
movl %eax, %ebp
movq %rbx, %rdi
callq 0x120db4
incl %r14d
cmpl %r14d, %r15d
jne 0xb72ed
jmp 0xb7357
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x121b03
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a4571(%rip), %rdx    # 0x35b911
movl $0x1, %edi
movl $0x58, %esi
movl $0x33, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
movq %rax, 0x18(%rbx)
movq $0x0, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb740f
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x10f386
leaq 0x2a4510(%rip), %rsi    # 0x35b911
movq %rbx, %rdi
movl $0x42, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb78a8
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb78e3
movq 0x38(%r14), %rdi
callq 0x10fe52
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0xb78db
movq 0x18(%r14), %rdx
addq $0x40, %r14
leaq 0x2fef41(%rip), %rsi    # 0x3b6809
movq %r14, %rdi
movq %rbx, %rcx
callq 0x10fe61
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1d8c1
// File: /workspace/github_c_makefile_star2_O1/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 0x2a39d2(%rip), %rdx    # 0x35c1a5
movl $0x1, %edi
movl $0x20, %esi
movl $0x29, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x121b54
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb8831
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121e8b
leaq 0x2a3982(%rip), %rsi    # 0x35c1a5
movq %rbx, %rdi
movl $0x36, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a3460(%rip), %rdx    # 0x35c3e4
movl $0x1, %edi
movl $0x18, %esi
movl $0x30, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb8fe0
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
leaq 0x2a3412(%rip), %rsi    # 0x35c3e4
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb90c2
movq %rdi, %r14
leaq 0x2a3435(%rip), %rdi    # 0x35c42e
leaq 0x2a3444(%rip), %rsi    # 0x35c444
callq 0x10cc4e
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2a265a(%rip), %rdi    # 0x35b66c
leaq 0x2a265b(%rip), %rsi    # 0x35b674
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fa96
movq 0x8(%r14), %rdx
leaq 0x2979a2(%rip), %rdi    # 0x3509e3
leaq 0x2a3439(%rip), %rsi    # 0x35c481
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fa96
leaq 0x14(%r14), %rdx
leaq 0x29a76e(%rip), %rdi    # 0x3537de
leaq 0x2a3506(%rip), %rsi    # 0x35c57d
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
addq $0x15, %r14
movq %r14, %rdi
callq 0x10f473
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x12b6d1(%rip), %rsi    # 0x1e4778
movq %rbx, %rdi
callq 0x10cda1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10d775
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1db32
// File: /workspace/github_c_makefile_star2_O1/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 0x120d23
movq %rax, %r15
testq %rbx, %rbx
je 0xb90f3
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb9196
testq %r14, %r14
je 0xb9191
leaq 0x2a34c5(%rip), %rsi    # 0x35c5c8
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xb9163
leaq 0x2b7d2a(%rip), %rsi    # 0x370e40
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xb916d
leaq 0x3359f4(%rip), %rsi    # 0x3eeb1d
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xb9177
leaq 0x2a9b46(%rip), %rsi    # 0x362c82
movq %r15, %rdi
callq 0x17a40
testl %eax, %eax
je 0xb9181
leaq 0x2a3482(%rip), %rsi    # 0x35c5d1
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xb918b
movl $0x0, 0x10(%r14)
jmp 0xb9189
movl $0x1, 0x10(%r14)
jmp 0xb9189
movl $0x2, 0x10(%r14)
jmp 0xb9189
movl $0x3, 0x10(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1dba0
callq 0x1db69
// File: /workspace/github_c_makefile_star2_O1/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 0xb965a
movq %rdi, %r14
leaq 0x2a1d9e(%rip), %rdi    # 0x35b2d6
leaq 0x2a311f(%rip), %rsi    # 0x35c65e
callq 0x10cc4e
movq %rax, %rbx
leaq 0x29a4f3(%rip), %rdi    # 0x353a41
leaq 0x2a3132(%rip), %rsi    # 0x35c687
movl $0x1f, %ecx
movl $0x1, %r8d
movq %r14, %rdx
callq 0x10f7ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x8(%r14), %rdx
leaq 0x3143e2(%rip), %rdi    # 0x3cd960
leaq 0x2a310f(%rip), %rsi    # 0x35c694
movl $0x3, %ecx
movl $0x1, %r8d
callq 0x10f7ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x20(%r14), %rdx
leaq 0x2d702b(%rip), %rdi    # 0x3905d6
leaq 0x2a30f8(%rip), %rsi    # 0x35c6aa
movl $0x1, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x10(%r14), %rdx
leaq 0x3034b6(%rip), %rdi    # 0x3bca93
leaq 0x2a1dde(%rip), %rsi    # 0x35b3c2
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
addq $0x18, %r14
leaq 0x2a30b7(%rip), %rdi    # 0x35c6c3
leaq 0x2a30b4(%rip), %rsi    # 0x35c6c7
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x10f4c7
movq %rax, %r14
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10cd10
leaq 0x12b139(%rip), %rsi    # 0x1e4778
movq %rbx, %rdi
callq 0x10cda1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10d775
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1dc82
// File: /workspace/github_c_makefile_star2_O1/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 0xb9688
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb9796
movq 0x40a8f1(%rip), %rax    # 0x4c3f80
movq (%rax), %rdx
testq %r15, %r15
je 0xb978e
leaq 0x296232(%rip), %rsi    # 0x34f8d4
movl $0x1, %edi
callq 0x108ed0
movq %rax, %r14
movq 0x10(%r15), %rdi
callq 0x120d23
movq %rax, %rdi
movl $0x87, %esi
movl $0x1, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1ae094
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xb9770
movq 0x10(%r15), %rdi
callq 0x120e13
movq %rax, %r12
movq 0x10(%r15), %rdi
leaq 0x2a301a(%rip), %rsi    # 0x35c70f
callq 0x12097f
leaq 0x8(%rsp), %rax
movq (%rax), %rbp
movq %rbp, %rdi
callq 0x1ae549
movq %rax, %r13
movq (%r15), %rax
movq %rax, 0x18(%rsp)
movq %r14, 0x20(%rsp)
movq 0x8(%r15), %r14
movq 0x18(%r15), %rax
movq %rax, 0x10(%rsp)
movzbl 0x20(%r15), %r15d
movq %r12, %rdi
callq 0x120d23
movq %rbp, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rdx
movq %r14, %rcx
movq 0x20(%rsp), %r14
movq 0x10(%rsp), %r8
movl %r15d, %r9d
pushq %rbx
pushq %rax
callq 0x1d1a78
addq $0x10, %rsp
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x1ae1ac
movq %r12, %rdi
callq 0x121b03
jmp 0xb9775
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r14, %rdi
callq 0x10916a
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rdi
callq 0x1dcf0
callq 0x1dcb9
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2a2261(%rip), %rdx    # 0x35c8a8
movl $0x1, %edi
movl $0x60, %esi
movl $0x2e, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x121b54
movq %rax, 0x28(%rbx)
callq 0x121b54
movq %rax, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xba6b5
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x28(%rbx), %rdi
callq 0x121e8b
movq 0x30(%rbx), %rdi
callq 0x121e8b
leaq 0x2a2201(%rip), %rsi    # 0x35c8a8
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a1803(%rip), %rdx    # 0x35cff7
movl $0x1, %edi
movl $0x60, %esi
movl $0x3b, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x28(%rbx)
movl $0x0, 0xc(%rbx)
callq 0x1208f8
movq %rax, 0x30(%rbx)
callq 0x1208f8
movq %rax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbb884
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x121b03
movq 0x40(%rbx), %rdi
callq 0x10f386
movq 0x48(%rbx), %rdi
callq 0x10f386
movq 0x30(%rbx), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x121b03
leaq 0x2a1781(%rip), %rsi    # 0x35cff7
movq %rbx, %rdi
movl $0x4e, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbbb94
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xbbc2c
testl %ebp, %ebp
je 0xbbbae
leaq 0x297ec2(%rip), %rsi    # 0x353a61
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movb $0x1, %bpl
jmp 0xbbbb0
xorl %ebp, %ebp
testb %bpl, %bpl
jne 0xbbbe7
movq 0x40(%r14), %rdi
callq 0x10fe52
testb %al, %al
je 0xbbbe7
leaq 0x18(%r14), %rdi
movq 0x30(%r14), %rdx
leaq 0x33273b(%rip), %rsi    # 0x3ee30c
movq %rbx, %rcx
callq 0x10fe61
testl %eax, %eax
movzbl %bpl, %eax
movl $0x1, %ebp
cmovel %eax, %ebp
testb %bpl, %bpl
jne 0xbbc21
movq 0x48(%r14), %rdi
callq 0x10fe52
testb %al, %al
je 0xbbc21
movq 0x38(%r14), %rdx
addq $0x20, %r14
leaq 0x297c9d(%rip), %rsi    # 0x3538a5
movq %r14, %rdi
movq %rbx, %rcx
callq 0x10fe61
testl %eax, %eax
movzbl %bpl, %eax
movl $0x1, %ebp
cmovel %eax, %ebp
movzbl %bpl, %eax
negl %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1dfc3
// File: /workspace/github_c_makefile_star2_O1/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 0x2a113d(%rip), %rdx    # 0x35d2f4
movl $0x1, %edi
movl $0x48, %esi
movl $0x31, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x121b54
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbc215
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121e8b
leaq 0x2a10ed(%rip), %rsi    # 0x35d2f4
movq %rbx, %rdi
movl $0x3d, %edx
popq %rbx
jmp 0x109670
retq