LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_mkfeatureindex.c
// Function: gt_mkfeatureindex_arguments_new
static void* gt_mkfeatureindex_arguments_new(void)
{
  GtMkfeatureindexArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->backend = gt_str_new();
  arguments->filename = gt_str_new();
  arguments->host = gt_str_new();
  arguments->user = gt_str_new();
  arguments->pass = gt_str_new();
  arguments->database = gt_str_new();
  arguments->input = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rax
movl $0x1, %edi
movl $0x40, %esi
leaq 0x4db54d(%rip), %rdx    # 0x52204f
movl $0x38, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_mkfeatureindex.c
// Function: gt_mkfeatureindex_arguments_delete
static void gt_mkfeatureindex_arguments_delete(void *tool_arguments)
{
  GtMkfeatureindexArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->backend);
  gt_str_delete(arguments->filename);
  gt_str_delete(arguments->host);
  gt_str_delete(arguments->user);
  gt_str_delete(arguments->pass);
  gt_str_delete(arguments->database);
  gt_str_delete(arguments->input);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x46bad
jmp 0x46c24
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4db435(%rip), %rsi    # 0x52204f
movl $0x4e, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x46e34
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x46dfc
jmp 0x46e34
movq 0x5f519d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cf206(%rip), %rsi    # 0x516013
leaq 0x4cf3ab(%rip), %rdx    # 0x5161bf
leaq 0x4db313(%rip), %rcx    # 0x52212e
leaq 0x4db22d(%rip), %r8     # 0x52204f
movl $0xaf, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x46e36
jmp 0x46e38
cmpq $0x0, 0x8(%rsp)
jne 0x46e78
movq 0x5f5159(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cf1c2(%rip), %rsi    # 0x516013
leaq 0x533d07(%rip), %rdx    # 0x57ab5f
leaq 0x4db2cf(%rip), %rcx    # 0x52212e
leaq 0x4db1e9(%rip), %r8     # 0x52204f
movl $0xb0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x46e7a
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x30, %esi
leaq 0x4dacd0(%rip), %rdx    # 0x5222a2
movl $0x38, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x1d43b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4763d
jmp 0x4768a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1d4420
movq 0x8(%rsp), %rdi
leaq 0x4dac22(%rip), %rsi    # 0x5222a2
movl $0x47, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x478a4
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4786c
jmp 0x478a4
movq 0x5f472d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ce796(%rip), %rsi    # 0x516013
leaq 0x4ce93b(%rip), %rdx    # 0x5161bf
leaq 0x4dab6d(%rip), %rcx    # 0x5223f8
leaq 0x4daa10(%rip), %r8     # 0x5222a2
movl $0x82, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x478a6
jmp 0x478a8
cmpq $0x0, 0x8(%rsp)
jne 0x478e8
movq 0x5f46e9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ce752(%rip), %rsi    # 0x516013
leaq 0x533297(%rip), %rdx    # 0x57ab5f
leaq 0x4dab29(%rip), %rcx    # 0x5223f8
leaq 0x4da9cc(%rip), %r8     # 0x5222a2
movl $0x83, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x478ea
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x8(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jge 0x4791e
movq 0x10(%rsp), %rdi
leaq 0x4dab06(%rip), %rsi    # 0x522415
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
callq 0x1235b0
movq %rax, (%rsp)
movq (%rsp), %rdi
leaq 0x4da660(%rip), %rsi    # 0x522475
leaq 0x3a4(%rip), %rdx       # 0x481c0
callq 0x123860
movq (%rsp), %rdi
leaq 0x4daf5d(%rip), %rsi    # 0x522d89
leaq 0x175d(%rip), %rdx      # 0x49590
callq 0x123860
movq (%rsp), %rdi
leaq 0x4db046(%rip), %rsi    # 0x522e89
leaq 0x1d06(%rip), %rdx      # 0x49b50
callq 0x123860
movq (%rsp), %rdi
leaq 0x4da623(%rip), %rsi    # 0x52247d
leaq 0x38f(%rip), %rdx       # 0x481f0
callq 0x123860
movq (%rsp), %rdi
leaq 0x4da619(%rip), %rsi    # 0x52248a
leaq 0x7e8(%rip), %rdx       # 0x48660
callq 0x123860
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x47f13
movq 0x5f40be(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ce127(%rip), %rsi    # 0x516013
leaq 0x4da5a1(%rip), %rdx    # 0x522494
leaq 0x4da5a8(%rip), %rcx    # 0x5224a2
leaq 0x4da5c2(%rip), %r8     # 0x5224c3
movl $0x3d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x47f15
leaq 0x4da5c2(%rip), %rdi    # 0x5224de
leaq 0x4da5e2(%rip), %rsi    # 0x522505
callq 0xf1420
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0xdba64(%rip), %rsi     # 0x1239a0
callq 0xf1770
movq (%rsp), %rdi
movl $0x1, %esi
callq 0xf2980
movq (%rsp), %rdi
callq 0xf1720
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x49566
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0x223230
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x27(%rsp)
jmp 0x4956b
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_packedindex_mkctxmap.c
// Function: parseMkCtxMapOptions
static GtOPrval
parseMkCtxMapOptions(int *parsed_args, int argc, const char **argv,
                     struct mkCtxMapOptions *params, GtError *err)
{
  GtOptionParser *op;
  GtOPrval oprval;
  GtOption *option;

  gt_error_check(err);
  op = gt_option_parser_new("indexname",
                         "Build BWT packedindex for project <indexname>.");
  gt_registerCtxMapOptions(op, &params->mapIntervalLog2);

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

  gt_option_parser_set_min_max_args(op, 1, 1);
  oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
                                  err);

  gt_option_parser_delete(op);

  return oprval;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x49a2c
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x499f4
jmp 0x49a2c
movq 0x5f25a5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cc60e(%rip), %rsi    # 0x516013
leaq 0x4cc7b3(%rip), %rdx    # 0x5161bf
leaq 0x4d9423(%rip), %rcx    # 0x522e36
leaq 0x4d9378(%rip), %r8     # 0x522d92
movl $0x95, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x49a2e
leaq 0x4ed3aa(%rip), %rdi    # 0x536ddf
leaq 0x4d940f(%rip), %rsi    # 0x522e4b
callq 0xf1420
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x21f520
movq 0x28(%rsp), %rdx
addq $0x4, %rdx
leaq 0x5185be(%rip), %rdi    # 0x562023
leaq 0x4d8c3b(%rip), %rsi    # 0x5226a7
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xf2a40
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %r9
leaq 0xdcc79(%rip), %r8      # 0x126730
callq 0xf2ab0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0xf5cf0
movl 0x14(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_packedindex_trsuftab.c
// Function: parseTrSufTabOptions
static GtOPrval
parseTrSufTabOptions(int *parsed_args, int argc, const char **argv,
                     struct trSufTabOptions *params, const GtStr *projectName,
                     GtError *err)
{
  GtOptionParser *op;
  GtOPrval oprval;
  GtOption *option;

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

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

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

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

  gt_option_parser_delete(op);

  return oprval;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x49d81
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x49d49
jmp 0x49d81
movq 0x5f2250(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cc2b9(%rip), %rsi    # 0x516013
leaq 0x4cc45e(%rip), %rdx    # 0x5161bf
leaq 0x4d914e(%rip), %rcx    # 0x522eb6
leaq 0x4d9123(%rip), %r8     # 0x522e92
movl $0x61, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x49d83
leaq 0x4ed055(%rip), %rdi    # 0x536ddf
leaq 0x4d90ba(%rip), %rsi    # 0x522e4b
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rcx
movl $0x2, %edx
callq 0x224bd0
movq 0x28(%rsp), %rdx
addq $0x38, %rdx
leaq 0x51825f(%rip), %rdi    # 0x562023
leaq 0x4d88dc(%rip), %rsi    # 0x5226a7
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xf2a40
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %r9
leaq 0xdc91c(%rip), %r8      # 0x126730
callq 0xf2ab0
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x224d20
movq 0x10(%rsp), %rdi
callq 0xf5cf0
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_paircmp.c
// Function: showsimpleoptions
static void showsimpleoptions(const Cmppairwiseopt *opt)
{
  if (gt_str_array_size(opt->strings) > 0)
  {
    if (!opt->showedist)
      printf("# two strings \"%s\" \"%s\"\n", gt_str_array_get(opt->strings,0),
             gt_str_array_get(opt->strings,1UL));
    return;
  }
  if (gt_str_array_size(opt->files) > 0)
  {
    if (opt->fasta)
    {
      printf("# two files fasta \"%s\" \"%s\"\n",gt_str_array_get(opt->files,1),
           gt_str_array_get(opt->files,2UL));
      return;
    }
    printf("# two files \"%s\" \"%s\"\n", gt_str_array_get(opt->files,0),
           gt_str_array_get(opt->files,1UL));
    return;
  }
  if (opt->charlistlen != NULL)
  {
    printf("# alphalen \"%s\" " GT_WU "\n",
           gt_str_get(opt->charlistlen->charlist),
           opt->charlistlen->len);
    return;
  }
  if (gt_str_length(opt->text) > 0)
  {
    printf("# text \"%s\"\n", gt_str_get(opt->text));
    return;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
callq 0x11fcc0
cmpq $0x0, %rax
jbe 0x4a9ba
movq 0x20(%rsp), %rax
testb $0x1, 0x31(%rax)
jne 0x4a9b5
movq 0x20(%rsp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11f8c0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x11f8c0
movq 0x18(%rsp), %rsi
movq %rax, %rdx
leaq 0x4d8813(%rip), %rdi    # 0x5231c1
movb $0x0, %al
callq 0x19070
jmp 0x4aad5
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11fcc0
cmpq $0x0, %rax
jbe 0x4aa65
movq 0x20(%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x4aa23
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x11f8c0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x2, %esi
callq 0x11f8c0
movq 0x10(%rsp), %rsi
movq %rax, %rdx
leaq 0x4d87c3(%rip), %rdi    # 0x5231da
movb $0x0, %al
callq 0x19070
jmp 0x4aad5
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11f8c0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x11f8c0
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x4d879b(%rip), %rdi    # 0x5231f7
movb $0x0, %al
callq 0x19070
jmp 0x4aad5
movq 0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4aaa2
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, %rsi
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x4d8775(%rip), %rdi    # 0x52320e
movb $0x0, %al
callq 0x19070
jmp 0x4aad5
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11dfa0
cmpq $0x0, %rax
jbe 0x4aad5
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11dee0
movq %rax, %rsi
leaq 0x4d8755(%rip), %rdi    # 0x523223
movb $0x0, %al
callq 0x19070
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4ab48
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4ab10
jmp 0x4ab48
movq 0x5f1489(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cb4f2(%rip), %rsi    # 0x516013
leaq 0x4cb697(%rip), %rdx    # 0x5161bf
leaq 0x4d8701(%rip), %rcx    # 0x523230
leaq 0x4d83a0(%rip), %r8     # 0x522ed6
movl $0x137, %r9d            # imm = 0x137
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ab4a
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x11f720
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_paircmp.c
// Function: freesimpleoption
static void freesimpleoption(Cmppairwiseopt *cmppairwise)
{
  gt_str_array_delete(cmppairwise->strings);
  gt_str_array_delete(cmppairwise->files);
  gt_str_delete(cmppairwise->text);
  if (cmppairwise->charlistlen != NULL)
  {
    gt_str_delete(cmppairwise->charlistlen->charlist);
    gt_free(cmppairwise->charlistlen);
  }
  if (cmppairwise->fasta)
  {
    gt_str_array_delete(cmppairwise->fastasequences0);
    gt_str_array_delete(cmppairwise->fastasequences1);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x11fd20
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11fd20
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4afaf
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x4d7f31(%rip), %rsi    # 0x522ed6
movl $0xee, %edx
callq 0xe88c0
movq (%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x4afd3
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11fd20
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11fd20
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_parsexrf.c
// Function: gt_parsexrf_arguments_delete
static void gt_parsexrf_arguments_delete(void *tool_arguments)
{
  GtParsexrfArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_delete(arguments->str_option_parsexrf);
    gt_free(arguments);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x4b08f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4d81dd(%rip), %rsi    # 0x523262
movl $0x28, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl $0x0, 0x24(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x4b183
movq 0x30(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4b14b
jmp 0x4b183
movq 0x5f0e4e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4caeb7(%rip), %rsi    # 0x516013
leaq 0x4cb05c(%rip), %rdx    # 0x5161bf
leaq 0x4d8168(%rip), %rcx    # 0x5232d2
leaq 0x4d80f1(%rip), %r8     # 0x523262
movl $0x41, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b185
movq 0x48(%rsp), %rax
movslq 0x44(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x30(%rsp), %rsi
callq 0x1f8a60
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0x4b1b2
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x24(%rsp)
jne 0x4b22b
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1f8f30
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x4b229
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1f8ec0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x4d80e2(%rip), %rsi    # 0x5232e5
callq 0x1f8910
movq %rax, %rsi
leaq 0x4dbcda(%rip), %rdi    # 0x526eec
movb $0x0, %al
callq 0x19070
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4b1c2
jmp 0x4b22b
movq 0x28(%rsp), %rdi
callq 0x1f8db0
movl 0x24(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_patternmatch.c
// Function: gt_patternmatch
int gt_patternmatch(int argc, const char **argv, GtError *err)
{
  bool haserr = false;
  int parsed_args;
  Pmatchoptions pmopt;
  GtOPrval oprval;

  gt_error_check(err);

  pmopt.indexname = gt_str_new();
  oprval = parse_options(&pmopt,&parsed_args, argc, argv, err);
  if (oprval == GT_OPTION_PARSER_OK)
  {
    gt_assert(parsed_args == argc);
    if (callpatternmatcher(&pmopt,err) != 0)
    {
      haserr = true;
    }
  }
  gt_str_delete(pmopt.indexname);
  if (oprval == GT_OPTION_PARSER_REQUESTS_EXIT)
  {
    return 0;
  }
  if (oprval == GT_OPTION_PARSER_ERROR)
  {
    return -1;
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x58, %rsp
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x4b2a7
movq 0x40(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4b26f
jmp 0x4b2a7
movq 0x5f0d2a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cad93(%rip), %rsi    # 0x516013
leaq 0x4caf38(%rip), %rdx    # 0x5161bf
leaq 0x4d8064(%rip), %rcx    # 0x5232f2
leaq 0x4d806d(%rip), %r8     # 0x523302
movl $0x133, %r9d            # imm = 0x133
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b2a9
callq 0x11d4a0
movq %rax, 0x30(%rsp)
movl 0x50(%rsp), %edx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4b390
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x4b33c
jmp 0x4b2dd
movl 0x38(%rsp), %eax
cmpl 0x50(%rsp), %eax
je 0x4b31f
movq 0x5f0cb2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cad1b(%rip), %rsi    # 0x516013
leaq 0x4cc5d9(%rip), %rdx    # 0x5178d8
leaq 0x4d7fec(%rip), %rcx    # 0x5232f2
leaq 0x4d7ff5(%rip), %r8     # 0x523302
movl $0x139, %r9d            # imm = 0x139
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4b321
movq 0x40(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x4b5e0
cmpl $0x0, %eax
je 0x4b33a
movb $0x1, 0x3f(%rsp)
jmp 0x4b33c
movq 0x30(%rsp), %rdi
callq 0x11f560
cmpl $0x2, 0xc(%rsp)
jne 0x4b357
movl $0x0, 0x54(%rsp)
jmp 0x4b37d
cmpl $0x1, 0xc(%rsp)
jne 0x4b368
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x4b37d
movb 0x3f(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/qgram2code.h
// Function: qgram2code
static inline unsigned int qgram2code(GtCodetype *code,
                                      const GtCodetype **multimappower,
                                      unsigned int qvalue,
                                      const GtUchar *qgram)
{
  int i;
  GtCodetype tmpcode = 0;
  GtUchar a;

  for (i=(int) (qvalue-1); i>=0; i--)
  {
    a = qgram[i];
    if (GT_ISSPECIAL(a))
    {
      return (unsigned int) i;
    }
    tmpcode += multimappower[i][a];
  }
  *code = tmpcode;
  return qvalue;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq %rcx, -0x28(%rsp)
movq $0x0, -0x38(%rsp)
movl -0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x2c(%rsp)
cmpl $0x0, -0x2c(%rsp)
jl 0x4bce3
movq -0x28(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x39(%rsp)
movzbl -0x39(%rsp), %eax
cmpl $0xfe, %eax
jl 0x4bcb5
movl -0x2c(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x4bcf8
movq -0x18(%rsp), %rax
movslq -0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movzbl -0x39(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq -0x38(%rsp), %rax
movq %rax, -0x38(%rsp)
movl -0x2c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x4bc87
movq -0x38(%rsp), %rcx
movq -0x10(%rsp), %rax
movq %rcx, (%rax)
movl -0x1c(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_patternmatch.c
// Function: comparemmsis
static void comparemmsis(const GtMMsearchiterator *mmsi1,
                         const GtMMsearchiterator *mmsi2)
{
  if (gt_mmsearchiterator_isempty(mmsi1))
  {
    if (!gt_mmsearchiterator_isempty(mmsi2))
    {
      fprintf(stderr,"mmsi1 is empty but mmsi2 not\n");
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  } else
  {
    if (gt_mmsearchiterator_isempty(mmsi2))
    {
      fprintf(stderr,"mmsi2 is empty but mmsi1 not\n");
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    if (!gt_mmsearchiterator_identical(mmsi1,mmsi2))
    {
      fprintf(stderr,"mmsi1 and mmsi2 are different\n");
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2383f0
testb $0x1, %al
jne 0x4bd1e
jmp 0x4bd50
movq 0x8(%rsp), %rdi
callq 0x2383f0
testb $0x1, %al
jne 0x4bd4e
movq 0x5f026d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d7739(%rip), %rsi    # 0x523476
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
jmp 0x4bdb9
movq 0x8(%rsp), %rdi
callq 0x2383f0
testb $0x1, %al
jne 0x4bd60
jmp 0x4bd82
movq 0x5f0239(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d7723(%rip), %rsi    # 0x523494
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x238430
testb $0x1, %al
jne 0x4bdb7
movq 0x5f0204(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d770c(%rip), %rsi    # 0x5234b2
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
jmp 0x4bdb9
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_prebwt.c
// Function: gt_prebwt_arguments_delete
static void gt_prebwt_arguments_delete(void *tool_arguments)
{
  Prebwtoptions *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->indexname);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4be2d
jmp 0x4be50
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4d768b(%rip), %rsi    # 0x5234d1
movl $0x2f, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x4beb3
movq 0x5f011e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ca187(%rip), %rsi    # 0x516013
leaq 0x4cb3f1(%rip), %rdx    # 0x517284
leaq 0x4d764d(%rip), %rcx    # 0x5234e7
leaq 0x4d7630(%rip), %r8     # 0x5234d1
movl $0x38, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4beb5
callq 0x11d4a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
leaq 0x4d7637(%rip), %rdi    # 0x523503
leaq 0x4d7649(%rip), %rsi    # 0x52351c
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x4cb3fb(%rip), %rsi    # 0x5172e4
callq 0xf1a10
movq 0x18(%rsp), %rax
movq (%rax), %rdx
leaq 0x4d2951(%rip), %rdi    # 0x51e84e
leaq 0x4cee73(%rip), %rsi    # 0x51ad77
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf1600
movq (%rsp), %rdi
callq 0xf6ca0
movq 0x18(%rsp), %rdx
addq $0x8, %rdx
leaq 0x4ecf58(%rip), %rdi    # 0x538e90
leaq 0x4d760b(%rip), %rsi    # 0x52354a
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0xf6510
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xd4e10
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x4bfe8
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0x4c00d
movq 0x30(%rsp), %rdi
callq 0xd6680
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4c00b
movb $0x1, 0x3f(%rsp)
jmp 0x4c00d
testb $0x1, 0x3f(%rsp)
jne 0x4c039
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rdx
xorl %esi, %esi
callq 0x22fa90
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x4c037
movb $0x1, 0x3f(%rsp)
jmp 0x4c039
testb $0x1, 0x3f(%rsp)
jne 0x4c0a5
movq 0x20(%rsp), %rdi
callq 0x7e8c0
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
callq 0x230ca0
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movl 0x14(%rsp), %esi
movq 0x48(%rsp), %rdx
movq 0x28(%rsp), %rax
movl 0x8(%rax), %ecx
callq 0x2618b0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x262430
cmpl $0x0, %eax
je 0x4c09b
movb $0x1, 0x3f(%rsp)
movq 0x8(%rsp), %rdi
callq 0x2617c0
movq 0x30(%rsp), %rdi
callq 0xd6ae0
cmpq $0x0, 0x40(%rsp)
je 0x4c0c1
movq 0x40(%rsp), %rdi
callq 0x22fd20
movb 0x3f(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
callq 0x1235b0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x54cf0
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x4d7422(%rip), %rsi    # 0x52356c
callq 0x1235f0
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x53ba0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x4f4c5c(%rip), %rsi    # 0x540dc9
callq 0x1235f0
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x4d5d0
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x4d73e6(%rip), %rsi    # 0x523576
callq 0x1235f0
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x4c580
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0x4d764b(%rip), %rsi    # 0x5237fe
callq 0x123690
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x50d50
movq 0x20(%rsp), %rdi
movq %rax, %rdx
leaq 0x4d86eb(%rip), %rsi    # 0x5248c1
callq 0x123690
movq 0x50(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x51e50
movq 0x28(%rsp), %rdi
movq %rax, %rdx
leaq 0x5368d6(%rip), %rsi    # 0x582acf
callq 0x123690
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x4f310
movq 0x30(%rsp), %rdi
movq %rax, %rdx
leaq 0x4d820b(%rip), %rsi    # 0x524427
callq 0x123690
movq 0x50(%rsp), %rax
movq %rax, 0x38(%rsp)
callq 0x4fef0
movq 0x38(%rsp), %rdi
movq %rax, %rdx
leaq 0x4d7340(%rip), %rsi    # 0x52357f
callq 0x123690
movq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
callq 0x56770
movq 0x40(%rsp), %rdi
movq %rax, %rdx
leaq 0x4d7325(%rip), %rsi    # 0x523587
callq 0x123690
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
callq 0x508a0
movq 0x48(%rsp), %rdi
movq %rax, %rdx
leaq 0x55264b(%rip), %rsi    # 0x59e8d0
callq 0x123690
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x4cb82a(%rip), %rdi    # 0x517b0a
leaq 0x4d72a8(%rip), %rsi    # 0x52358f
callq 0xf1420
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x254233(%rip), %rsi    # 0x2a0530
callq 0xf17f0
movq 0x8(%rsp), %rdi
leaq 0x1359d2(%rip), %rsi    # 0x181ce0
xorl %eax, %eax
movl %eax, %edx
callq 0xf1770
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0xf2980
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_readjoiner_asqg.c
// Function: gt_readjoiner_asqg_arguments_delete
static void gt_readjoiner_asqg_arguments_delete(void *tool_arguments)
{
  GtReadjoinerAsqgArguments *arguments = tool_arguments;
  if (!arguments)
    return;
  gt_str_delete(arguments->readset);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4c60d
jmp 0x4c631
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4d7021(%rip), %rsi    # 0x523648
movl $0x39, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
callq 0xe8ea0
testb $0x1, %al
jne 0x4d377
jmp 0x4d441
callq 0xe8b80
movq %rax, 0x18(%rsp)
callq 0xdbac0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4d3a1
leaq 0x55028e(%rip), %rax    # 0x59d628
movq %rax, 0x8(%rsp)
jmp 0x4d3ab
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, %rdx
addq %rax, %rdx
movq %rdx, %xmm0
movaps 0x4cb564(%rip), %xmm4   # 0x518930
punpckldq %xmm4, %xmm0    # xmm0 = xmm0[0],xmm4[0],xmm0[1],xmm4[1]
movapd 0x4cb568(%rip), %xmm3   # 0x518940
subpd %xmm3, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd 0x4cb539(%rip), %xmm2   # 0x518928
mulsd %xmm2, %xmm0
movq %rcx, %xmm1
punpckldq %xmm4, %xmm1    # xmm1 = xmm1[0],xmm4[0],xmm1[1],xmm4[1]
subpd %xmm3, %xmm1
movaps %xmm1, %xmm5
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm5, %xmm1
mulsd %xmm2, %xmm1
movq %rax, %xmm2
punpckldq %xmm4, %xmm2    # xmm2 = xmm2[0],xmm4[0],xmm2[1],xmm4[1]
subpd %xmm3, %xmm2
movaps %xmm2, %xmm3
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm3, %xmm2
movsd 0x4cb4f1(%rip), %xmm3   # 0x518920
divsd %xmm3, %xmm2
leaq 0x4d64e7(%rip), %rdi    # 0x523921
movb $0x3, %al
callq 0xe7740
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq 0x90(%rsp), %rax
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movl %r8d, 0x68(%rsp)
movq %r9, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
callq 0x11d4a0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x4d4c3
movq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x68(%rsp), %eax
jae 0x4d5b9
movq 0x28(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x11d550
movq 0x28(%rsp), %rdi
movl $0x2e, %esi
callq 0x11da70
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x11de00
movq 0x28(%rsp), %rdi
leaq 0x4d7abf(%rip), %rsi    # 0x524fd0
callq 0x11d550
movq 0x28(%rsp), %rdi
callq 0x11dee0
movq %rax, 0x18(%rsp)
movl 0x6c(%rsp), %eax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x4d545
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x4d553
leaq 0x241754(%rip), %rax    # 0x28eca0
movq %rax, 0x10(%rsp)
jmp 0x4d553
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x4d570
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
jmp 0x4d57b
leaq 0x38(%rsp), %rax
movq %rax, (%rsp)
jmp 0x4d57b
movq 0x8(%rsp), %rdx
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdi
movq (%rsp), %rcx
movq 0x90(%rsp), %r8
callq 0x28bd10
movl %eax, 0x5c(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11e110
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x4d4cb
movq 0x28(%rsp), %rdi
callq 0x11f560
movl 0x5c(%rsp), %eax
addq $0x88, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x58, %esi
leaq 0x4d6347(%rip), %rdx    # 0x523959
movl $0x33, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4d67d
jmp 0x4d6bd
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xf5df0
movq 0x8(%rsp), %rdi
leaq 0x4d62a6(%rip), %rsi    # 0x523959
movl $0x42, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4dd24
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4dcec
jmp 0x4dd24
movq 0x5ee2ad(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4c8316(%rip), %rsi    # 0x516013
leaq 0x4c84bb(%rip), %rdx    # 0x5161bf
leaq 0x4d608f(%rip), %rcx    # 0x523d9a
leaq 0x4d5c47(%rip), %r8     # 0x523959
movl $0xe9, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4dd26
cmpl $0x0, 0x4(%rsp)
jne 0x4dd73
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xf74a0
testb $0x1, %al
jne 0x4dd41
jmp 0x4dd73
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x10(%rsp), %rcx
leaq 0x531f93(%rip), %rsi    # 0x57fcf2
callq 0xf7500
cmpl $0x0, %eax
je 0x4dd71
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x4dd73
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)