LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_mkfeatureindex.c
// Function: gt_mkfeatureindex_arguments_check
static int gt_mkfeatureindex_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  GT_UNUSED GtMkfeatureindexArguments *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 0x3469f
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x346d6
testq %rbx, %rbx
je 0x346a8
xorl %eax, %eax
popq %rbx
retq
movq 0x4038b9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b095a(%rip), %rsi    # 0x2e5013
leaq 0x313f93(%rip), %rdx    # 0x348653
leaq 0x2bc9fc(%rip), %rcx    # 0x2f10c3
leaq 0x2bc916(%rip), %r8     # 0x2f0fe4
movl $0xb0, %r9d
jmp 0x34702
movq 0x40388b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b092c(%rip), %rsi    # 0x2e5013
leaq 0x2b0ad1(%rip), %rdx    # 0x2e51bf
leaq 0x2bc9ce(%rip), %rcx    # 0x2f10c3
leaq 0x2bc8e8(%rip), %r8     # 0x2f0fe4
movl $0xaf, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2bc5de(%rip), %rdx    # 0x2f1236
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
pushq $0x38
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x9b6b4
movq %rax, 0x18(%rbx)
callq 0xae154
movq %rax, 0x10(%rbx)
callq 0x116724
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34cc8
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x8da06
movq 0x18(%rbx), %rdi
callq 0x9ba24
movq 0x10(%rbx), %rdi
callq 0xae662
movq 0x28(%rbx), %rdi
callq 0x116765
leaq 0x2bc57a(%rip), %rsi    # 0x2f1236
pushq $0x47
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x34e19
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x34e74
testq %r14, %r14
je 0x34e46
movl 0xc(%r14), %ecx
xorl %eax, %eax
cmpl 0x8(%r14), %ecx
jns 0x34e3e
leaq 0x2bc578(%rip), %rsi    # 0x2f13a9
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40311b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b01bc(%rip), %rsi    # 0x2e5013
leaq 0x3137f5(%rip), %rdx    # 0x348653
leaq 0x2bc527(%rip), %rcx    # 0x2f138c
leaq 0x2bc3ca(%rip), %r8     # 0x2f1236
movl $0x83, %r9d
jmp 0x34ea0
movq 0x4030ed(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b018e(%rip), %rsi    # 0x2e5013
leaq 0x2b0333(%rip), %rdx    # 0x2e51bf
leaq 0x2bc4f9(%rip), %rcx    # 0x2f138c
leaq 0x2bc39c(%rip), %r8     # 0x2f1236
movl $0x82, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xb0c26
movq %rax, %rbx
leaq 0x2bc23e(%rip), %rsi    # 0x2f1409
leaq 0x284(%rip), %rdx       # 0x35456
movq %rax, %rdi
callq 0xb0dd5
leaq 0x2bcb38(%rip), %rsi    # 0x2f1d19
leaq 0xef0(%rip), %rdx       # 0x360d8
movq %rbx, %rdi
callq 0xb0dd5
leaq 0x2bcc22(%rip), %rsi    # 0x2f1e19
leaq 0x122a(%rip), %rdx      # 0x36428
movq %rbx, %rdi
callq 0xb0dd5
leaq 0x2bc204(%rip), %rsi    # 0x2f1411
leaq 0x254(%rip), %rdx       # 0x35468
movq %rbx, %rdi
callq 0xb0dd5
leaq 0x2bc1fb(%rip), %rsi    # 0x2f141e
leaq 0x502(%rip), %rdx       # 0x3572c
movq %rbx, %rdi
callq 0xb0dd5
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x35293
movq %rdi, %rbx
leaq 0x2bc21e(%rip), %rdi    # 0x2f1472
leaq 0x2bc23e(%rip), %rsi    # 0x2f1499
callq 0x97df5
movq %rax, %r14
leaq 0x7bc2e(%rip), %rsi     # 0xb0e98
movq %rax, %rdi
movq %rbx, %rdx
callq 0x98045
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x98be7
movq %r14, %rdi
callq 0x98002
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x402cce(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2afd6f(%rip), %rsi    # 0x2e5013
leaq 0x2bc17d(%rip), %rdx    # 0x2f1428
leaq 0x2bc184(%rip), %rcx    # 0x2f1436
leaq 0x2bc19e(%rip), %r8     # 0x2f1457
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-bwtseq-siop.h
// Function: EMIGetNextMatch
static inline bool
EMIGetNextMatch(struct BWTSeqExactMatchesIterator *iter, GtUword *pos,
                const BWTSeq *bwtSeq)
{
  if (iter->nextMatchBWTPos < iter->bounds.end)
  {
    /*printf("nextMatchBWTPos="GT_WU"\n",(GtUword) iter->nextMatchBWTPos);*/
    *pos = gt_BWTSeqLocateMatch(bwtSeq, iter->nextMatchBWTPos, &iter->extBits);
    iter->nextMatchBWTPos++;
    return true;
  }
  else
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %rbx
cmpq %r12, %rbx
jae 0x360c4
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rdx, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x1457be
movq %rax, (%r15)
incq 0x10(%r14)
cmpq %r12, %rbx
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x37130
movq %rcx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x37145
movq %r14, %rdi
movq %rbx, %rsi
callq 0xae22f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x400e1c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2adebd(%rip), %rsi    # 0x2e5013
leaq 0x2ae062(%rip), %rdx    # 0x2e51bf
leaq 0x2bb05c(%rip), %rcx    # 0x2f21c0
leaq 0x2bacfb(%rip), %r8     # 0x2f1e66
movl $0x137, %r9d            # imm = 0x137
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x3725f
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x372cd
movslq %ebp, %rax
movq (%r14,%rax,8), %rdi
movq %rbx, %rsi
callq 0x12d190
movq %rax, %rbx
testq %rax, %rax
je 0x372b0
xorl %r14d, %r14d
leaq 0x2baff5(%rip), %r15    # 0x2f2275
movq %rbx, %rdi
callq 0x12dbff
cmpq %rax, %r14
jae 0x372b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12dbb4
movq %rax, %rdi
movq %r15, %rsi
callq 0x12d0b2
movq %rax, %rdi
callq 0x17b60
incq %r14
jmp 0x37280
xorl %ebp, %ebp
cmpq $0x1, %rbx
sbbl %ebp, %ebp
movq %rbx, %rdi
callq 0x12db0a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x400c94(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2add35(%rip), %rsi    # 0x2e5013
leaq 0x2adeda(%rip), %rdx    # 0x2e51bf
leaq 0x2baf76(%rip), %rcx    # 0x2f2262
leaq 0x2baeff(%rip), %r8     # 0x2f21f2
pushq $0x41
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x37b76
movq %rdi, %rbx
callq 0xacb84
movq %rax, (%rbx)
leaq 0x2ba99d(%rip), %rdi    # 0x2f2493
leaq 0x2ba9af(%rip), %rsi    # 0x2f24ac
callq 0x97df5
movq %rax, %r14
leaq 0x2ae7c0(%rip), %rsi    # 0x2e62cc
movq %rax, %rdi
callq 0x98288
movq (%rbx), %rdx
leaq 0x2b5c90(%rip), %rdi    # 0x2ed7ae
leaq 0x2b21f7(%rip), %rsi    # 0x2e9d1c
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9ae37
addq $0x8, %rbx
leaq 0x2cff0e(%rip), %rdi    # 0x307a5b
leaq 0x2ba986(%rip), %rsi    # 0x2f24da
pushq $0x1
popq %r8
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x9abef
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x4003eb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2ad48c(%rip), %rsi    # 0x2e5013
leaq 0x2ae6de(%rip), %rdx    # 0x2e626c
leaq 0x2ba8e2(%rip), %rcx    # 0x2f2477
leaq 0x2ba8c5(%rip), %r8     # 0x2f2461
pushq $0x38
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %r13
movq (%rcx), %rdi
callq 0xad1fa
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x87eb0
movq %rax, %rbx
testq %rax, %rax
je 0x37c06
movq %r14, 0x10(%rsp)
sete %r15b
movq %rbx, %rdi
callq 0x88545
movq %rax, %rbp
testq %rax, %rax
sete %r14b
orb %r15b, %r14b
pushq $0x1
popq %rax
je 0x37c0e
xorl %r15d, %r15d
jmp 0x37c2e
movb $0x1, %r14b
xorl %r15d, %r15d
jmp 0x37c83
movq %r12, %rdi
xorl %esi, %esi
movq 0x10(%rsp), %rdx
callq 0x14b51f
movq %rax, %r15
pushq $0x1
popq %rax
testq %r15, %r15
movzbl %r14b, %r14d
cmovel %eax, %r14d
testb %r14b, %r14b
jne 0x37c83
movq %rbp, %rdi
movl %eax, %ebp
callq 0x56c8e
movl %eax, 0xc(%rsp)
movq %r15, %rdi
callq 0x14bef7
movl 0x8(%r13), %ecx
movq %r15, %rdi
movl 0xc(%rsp), %esi
movq %rax, %rdx
callq 0x166d24
movq %rax, %r13
movq %r12, %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rdx
callq 0x1673b1
testl %eax, %eax
movzbl %r14b, %eax
cmovel %eax, %ebp
movq %r13, %rdi
callq 0x166c70
movl %ebp, %r14d
movq %rbx, %rdi
callq 0x888b5
testq %r15, %r15
je 0x37c98
movq %r15, %rdi
callq 0x14b703
movzbl %r14b, %eax
negl %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0xb0c26
movq %rax, %rbx
callq 0x3d744
leaq 0x2ba7f4(%rip), %rsi    # 0x2f24fc
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x3cce0
leaq 0x2d7693(%rip), %rsi    # 0x30f3b2
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x38b08
leaq 0x2ba7d0(%rip), %rsi    # 0x2f2506
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0c55
callq 0x37fc8
leaq 0x2baa41(%rip), %rsi    # 0x2f278e
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0cbf
callq 0x3af3c
leaq 0x2bba8c(%rip), %rsi    # 0x2f37f0
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0cbf
callq 0x3bad4
leaq 0x318432(%rip), %rsi    # 0x3501ad
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0cbf
callq 0x39e28
leaq 0x2bb5c4(%rip), %rsi    # 0x2f3356
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0cbf
callq 0x3a5e4
leaq 0x2ba766(%rip), %rsi    # 0x2f250f
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0cbf
callq 0x3e640
leaq 0x2ba757(%rip), %rsi    # 0x2f2517
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0cbf
callq 0x3abe4
leaq 0x333855(%rip), %rsi    # 0x36b62c
movq %rbx, %rdi
movq %rax, %rdx
callq 0xb0cbf
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2aecf9(%rip), %rdi    # 0x2e6af2
leaq 0x2ba71f(%rip), %rsi    # 0x2f251f
callq 0x97df5
movq %rax, %rbx
leaq 0x1508b5(%rip), %rsi    # 0x1886c4
movq %rax, %rdi
callq 0x9808c
leaq 0xaf6ce(%rip), %rsi     # 0xe74ec
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98045
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x98be7
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_readjoiner_asqg.c
// Function: gt_readjoiner_asqg_show_current_space
static inline void gt_readjoiner_asqg_show_current_space(const char *label)
{
  GtUword m, f;
  if (gt_ma_bookkeeping_enabled())
  {
    m = gt_ma_get_space_current();
    f = gt_fa_get_space_current();
    gt_log_log("used space after %s: %.2f MB (ma: %.2f MB; fa: %.2f MB)",
        label == NULL ? "" : label, GT_MEGABYTES(m + f), GT_MEGABYTES(m),
        GT_MEGABYTES(f));
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x93b7c
testb %al, %al
je 0x38a29
callq 0x93934
movq %rax, %r14
callq 0x8bf8b
testq %rbx, %rbx
leaq 0x331bd3(%rip), %rsi    # 0x36a570
cmovneq %rbx, %rsi
leaq (%rax,%r14), %rcx
movq %rcx, %xmm1
movq 0x2aef2e(%rip), %xmm2   # 0x2e78e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x2aef32(%rip), %xmm3   # 0x2e78f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x2aef2a(%rip), %xmm4   # 0x2e7900
mulsd %xmm4, %xmm0
movq %r14, %xmm5
punpckldq %xmm2, %xmm5    # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
subpd %xmm3, %xmm5
movapd %xmm5, %xmm1
unpckhpd %xmm5, %xmm1            # xmm1 = xmm1[1],xmm5[1]
addsd %xmm5, %xmm1
mulsd %xmm4, %xmm1
movq %rax, %xmm5
punpckldq %xmm2, %xmm5    # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
subpd %xmm3, %xmm5
movapd %xmm5, %xmm2
unpckhpd %xmm5, %xmm2            # xmm2 = xmm2[1],xmm5[1]
addsd %xmm5, %xmm2
mulsd %xmm4, %xmm2
leaq 0x2b9e96(%rip), %rdi    # 0x2f28b1
movb $0x3, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92a82
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movl %r8d, 0xc(%rsp)
movl %ecx, %ebp
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, %r13
callq 0xacb84
movq %rax, %r15
testq %rbx, %rbx
je 0x38a80
leaq 0x18(%rsp), %rax
movq %rbx, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x1464e9(%rip), %r13    # 0x17ef66
movq %rax, %r12
movl %ebp, %ebp
xorl %r14d, %r14d
xorl %ebx, %ebx
cmpl %r14d, 0xc(%rsp)
je 0x38aed
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0xacbfb
movq %r15, %rdi
pushq $0x2e
popq %rsi
callq 0xaced9
movq %r15, %rdi
movl %r14d, %esi
callq 0xad151
movq %r15, %rdi
leaq 0x2bb444(%rip), %rsi    # 0x2f3eff
callq 0xacbfb
movq %r15, %rdi
callq 0xad1fa
movq %rax, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq 0x70(%rsp), %r8
callq 0x17d808
movl %eax, %ebx
movq %r15, %rdi
callq 0xad357
incl %r14d
jmp 0x38a87
movq %r15, %rdi
callq 0xae103
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x2b9db1(%rip), %rdx    # 0x2f28e9
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
pushq $0x33
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
andq $0x0, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x38b9c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0x9a8ea
leaq 0x2b9d59(%rip), %rsi    # 0x2f28e9
pushq $0x42
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3905c
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x39097
movq 0x38(%r14), %rdi
callq 0x9b4cb
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x3908f
movq 0x18(%r14), %rdx
addq $0x40, %r14
leaq 0x3144dd(%rip), %rsi    # 0x34d559
movq %r14, %rdi
movq %rbx, %rcx
callq 0x9b50d
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3feeca(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2abf6b(%rip), %rsi    # 0x2e5013
leaq 0x2ac110(%rip), %rdx    # 0x2e51bf
leaq 0x2b9c74(%rip), %rcx    # 0x2f2d2a
leaq 0x2b982c(%rip), %r8     # 0x2f28e9
movl $0xe9, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_readjoiner_assembly.c
// Function: gt_readjoiner_assembly_show_current_space
static inline void gt_readjoiner_assembly_show_current_space(const char *label)
{
  GtUword m, f;
  if (gt_ma_bookkeeping_enabled())
  {
    m = gt_ma_get_space_current();
    f = gt_fa_get_space_current();
    gt_log_log("used space %s: %.2f MB (ma: %.2f MB; fa: %.2f MB)",
        label == NULL ? "" : label, GT_MEGABYTES(m + f), GT_MEGABYTES(m),
        GT_MEGABYTES(f));
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x93b7c
testb %al, %al
je 0x39e1d
callq 0x93934
movq %rax, %r14
callq 0x8bf8b
testq %rbx, %rbx
leaq 0x3307df(%rip), %rsi    # 0x36a570
cmovneq %rbx, %rsi
leaq (%rax,%r14), %rcx
movq %rcx, %xmm1
movq 0x2adb3a(%rip), %xmm2   # 0x2e78e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x2adb3e(%rip), %xmm3   # 0x2e78f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x2adb36(%rip), %xmm4   # 0x2e7900
mulsd %xmm4, %xmm0
movq %r14, %xmm5
punpckldq %xmm2, %xmm5    # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
subpd %xmm3, %xmm5
movapd %xmm5, %xmm1
unpckhpd %xmm5, %xmm1            # xmm1 = xmm1[1],xmm5[1]
addsd %xmm5, %xmm1
mulsd %xmm4, %xmm1
movq %rax, %xmm5
punpckldq %xmm2, %xmm5    # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
subpd %xmm3, %xmm5
movapd %xmm5, %xmm2
unpckhpd %xmm5, %xmm2            # xmm2 = xmm2[1],xmm5[1]
addsd %xmm5, %xmm2
mulsd %xmm4, %xmm2
leaq 0x2b929c(%rip), %rdi    # 0x2f30ab
movb $0x3, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92a82
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x2b932a(%rip), %rdx    # 0x2f317d
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x29
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xae154
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x39ea9
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae662
leaq 0x2b92e0(%rip), %rsi    # 0x2f317d
pushq $0x36
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b8da8(%rip), %rdx    # 0x2f33bc
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x30
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3a668
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
leaq 0x2b8d60(%rip), %rsi    # 0x2f33bc
pushq $0x3d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3a74a
movq %rdi, %r14
leaq 0x2b8d85(%rip), %rdi    # 0x2f3406
leaq 0x2b8d94(%rip), %rsi    # 0x2f341c
callq 0x97df5
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2b7faa(%rip), %rdi    # 0x2f2644
leaq 0x2b7fab(%rip), %rsi    # 0x2f264c
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9ae37
movq 0x8(%r14), %rdx
leaq 0x2ad31a(%rip), %rdi    # 0x2e79e3
leaq 0x2b8d89(%rip), %rsi    # 0x2f3459
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x9ae37
leaq 0x14(%r14), %rdx
leaq 0x2b00c5(%rip), %rdi    # 0x2ea7bd
leaq 0x2b8e56(%rip), %rsi    # 0x2f3555
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
addq $0x15, %r14
movq %r14, %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x14df95(%rip), %rsi    # 0x1886c4
movq %rbx, %rdi
callq 0x9808c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x98c29
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x3fd817(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2aa8b8(%rip), %rsi    # 0x2e5013
leaq 0x30def1(%rip), %rdx    # 0x348653
leaq 0x2b8c75(%rip), %rcx    # 0x2f33de
leaq 0x2b8c4c(%rip), %r8     # 0x2f33bc
pushq $0x46
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xad1fa
movq %rax, %r15
testq %rbx, %rbx
je 0x3a7ac
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x3a83c
leaq 0x2b8ded(%rip), %rsi    # 0x2f35a0
movq %r15, %rdi
callq 0x179e0
testl %eax, %eax
je 0x3a811
leaq 0x2cd3a2(%rip), %rsi    # 0x307b68
movq %r15, %rdi
callq 0x179e0
testl %eax, %eax
je 0x3a818
leaq 0x34af7d(%rip), %rsi    # 0x385756
movq %r15, %rdi
callq 0x179e0
testl %eax, %eax
je 0x3a822
leaq 0x2bf411(%rip), %rsi    # 0x2f9bfd
movq %r15, %rdi
callq 0x179e0
testl %eax, %eax
je 0x3a82c
leaq 0x2b8daa(%rip), %rsi    # 0x2f35a9
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
jmp 0x3a836
andl $0x0, 0x10(%r14)
jmp 0x3a834
movl $0x1, 0x10(%r14)
jmp 0x3a834
movl $0x2, 0x10(%r14)
jmp 0x3a834
movl $0x3, 0x10(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x3fd725(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2aa7c6(%rip), %rsi    # 0x2e5013
leaq 0x2aa96b(%rip), %rdx    # 0x2e51bf
leaq 0x2b8d1f(%rip), %rcx    # 0x2f357a
leaq 0x2b8b5a(%rip), %r8     # 0x2f33bc
pushq $0x73
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_readjoiner_gfa.c
// Function: gt_readjoiner_gfa_show_current_space
static inline void gt_readjoiner_gfa_show_current_space(const char *label)
{
  GtUword m, f;
  if (gt_ma_bookkeeping_enabled())
  {
    m = gt_ma_get_space_current();
    f = gt_fa_get_space_current();
    gt_log_log("used space after %s: %.2f MB (ma: %.2f MB; fa: %.2f MB)",
        label == NULL ? "" : label, GT_MEGABYTES(m + f), GT_MEGABYTES(m),
        GT_MEGABYTES(f));
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x93b7c
testb %al, %al
je 0x3b9f5
callq 0x93934
movq %rax, %r14
callq 0x8bf8b
testq %rbx, %rbx
leaq 0x32ec07(%rip), %rsi    # 0x36a570
cmovneq %rbx, %rsi
leaq (%rax,%r14), %rcx
movq %rcx, %xmm1
movq 0x2abf62(%rip), %xmm2   # 0x2e78e0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x2abf66(%rip), %xmm3   # 0x2e78f0
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movsd 0x2abf5e(%rip), %xmm4   # 0x2e7900
mulsd %xmm4, %xmm0
movq %r14, %xmm5
punpckldq %xmm2, %xmm5    # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
subpd %xmm3, %xmm5
movapd %xmm5, %xmm1
unpckhpd %xmm5, %xmm1            # xmm1 = xmm1[1],xmm5[1]
addsd %xmm5, %xmm1
mulsd %xmm4, %xmm1
movq %rax, %xmm5
punpckldq %xmm2, %xmm5    # xmm5 = xmm5[0],xmm2[0],xmm5[1],xmm2[1]
subpd %xmm3, %xmm5
movapd %xmm5, %xmm2
unpckhpd %xmm5, %xmm2            # xmm2 = xmm2[1],xmm5[1]
addsd %xmm5, %xmm2
mulsd %xmm4, %xmm2
leaq 0x2b6eca(%rip), %rdi    # 0x2f28b1
movb $0x3, %al
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x92a82
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b7d81(%rip), %rdx    # 0x2f3880
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
pushq $0x2e
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xae154
movq %rax, 0x28(%rbx)
callq 0xae154
movq %rax, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3bb65
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x28(%rbx), %rdi
callq 0xae662
movq 0x30(%rbx), %rdi
callq 0xae662
leaq 0x2b7d27(%rip), %rsi    # 0x2f3880
pushq $0x3d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b72bf(%rip), %rdx    # 0x2f3fcf
pushq $0x1
popq %rdi
pushq $0x60
popq %rsi
pushq $0x3b
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x28(%rbx)
andl $0x0, 0xc(%rbx)
callq 0xacb84
movq %rax, 0x30(%rbx)
callq 0xacb84
movq %rax, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3cd95
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0xae103
movq 0x40(%rbx), %rdi
callq 0x9a8ea
movq 0x48(%rbx), %rdi
callq 0x9a8ea
movq 0x30(%rbx), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0xae103
leaq 0x2b7246(%rip), %rsi    # 0x2f3fcf
pushq $0x4e
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d0c8
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x3d142
testl %ebp, %ebp
je 0x3d0e5
leaq 0x2ad96d(%rip), %rsi    # 0x2eaa40
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x40(%r14), %rdi
callq 0x9b4cb
testb %al, %al
je 0x3d10d
leaq 0x18(%r14), %rdi
movq 0x30(%r14), %rdx
leaq 0x347e27(%rip), %rsi    # 0x384f28
movq %rbx, %rcx
callq 0x9b50d
testl %eax, %eax
jne 0x3d0dd
movq 0x48(%r14), %rdi
callq 0x9b4cb
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x3d0e0
movq 0x38(%r14), %rdx
addq $0x20, %r14
leaq 0x2ad757(%rip), %rsi    # 0x2ea884
movq %r14, %rdi
movq %rbx, %rcx
callq 0x9b50d
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
jmp 0x3d0e0
movq 0x3fae1f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a7ec0(%rip), %rsi    # 0x2e5013
leaq 0x2a8065(%rip), %rdx    # 0x2e51bf
leaq 0x2b707e(%rip), %rcx    # 0x2f41df
leaq 0x2b6e67(%rip), %r8     # 0x2f3fcf
movl $0xc5, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2b6b5d(%rip), %rdx    # 0x2f42cc
pushq $0x1
popq %rdi
pushq $0x48
popq %rsi
pushq $0x31
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xae154
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3d7c5
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae662
leaq 0x2b6b13(%rip), %rsi    # 0x2f42cc
pushq $0x3d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b64ed(%rip), %rdx    # 0x2f4b5d
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x30
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3e6c4
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
leaq 0x2b64a5(%rip), %rsi    # 0x2f4b5d
pushq $0x3d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xad1fa
movq %rax, %r15
testq %rbx, %rbx
je 0x3e830
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x3e8c0
leaq 0x2b4d69(%rip), %rsi    # 0x2f35a0
movq %r15, %rdi
callq 0x179e0
testl %eax, %eax
je 0x3e895
leaq 0x2c931e(%rip), %rsi    # 0x307b68
movq %r15, %rdi
callq 0x179e0
testl %eax, %eax
je 0x3e89c
leaq 0x346ef9(%rip), %rsi    # 0x385756
movq %r15, %rdi
callq 0x179e0
testl %eax, %eax
je 0x3e8a6
leaq 0x30fc1d(%rip), %rsi    # 0x34e48d
movq %r15, %rdi
callq 0x179e0
testl %eax, %eax
je 0x3e8b0
leaq 0x2b4d26(%rip), %rsi    # 0x2f35a9
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
jmp 0x3e8ba
andl $0x0, 0x10(%r14)
jmp 0x3e8b8
movl $0x1, 0x10(%r14)
jmp 0x3e8b8
movl $0x2, 0x10(%r14)
jmp 0x3e8b8
movl $0x3, 0x10(%r14)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x3f96a1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a6742(%rip), %rsi    # 0x2e5013
leaq 0x2a68e7(%rip), %rdx    # 0x2e51bf
leaq 0x2b641c(%rip), %rcx    # 0x2f4cfb
leaq 0x2b6277(%rip), %r8     # 0x2f4b5d
pushq $0x78
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x3edfa
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x3ee2d
testq %rbx, %rbx
je 0x3ee03
xorl %eax, %eax
popq %rbx
retq
movq 0x3f915e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a61ff(%rip), %rsi    # 0x2e5013
leaq 0x309838(%rip), %rdx    # 0x348653
leaq 0x2b6053(%rip), %rcx    # 0x2f4e75
leaq 0x2b5f15(%rip), %r8     # 0x2f4d3e
pushq $0x73
jmp 0x3ee55
movq 0x3f9134(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2a61d5(%rip), %rsi    # 0x2e5013
leaq 0x2a637a(%rip), %rdx    # 0x2e51bf
leaq 0x2b6029(%rip), %rcx    # 0x2f4e75
leaq 0x2b5eeb(%rip), %r8     # 0x2f4d3e
pushq $0x72
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390