LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_chseqids.c
// Function: gt_chseqids_option_parser_new
static GtOptionParser* gt_chseqids_option_parser_new(void *tool_arguments)
{
  ChseqidsArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] mapping_file [GFF3_file]",
                         "Change sequence ids by the mapping given in a "
                         "mapping file.");

  /* -sort */
  option = gt_option_new_bool("sort",
                              "sort the GFF3 features after changing the "
                              "sequence ids\n(memory consumption is "
                              "proportional to the input file size)",
                              &arguments->sort, false);
  gt_option_parser_add_option(op, option);

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

  /* output file options */
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  /* parse options */
  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_min_max_args(op, 1, 2);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9aa77
movq %rdi, %r14
leaq 0x2abf1d(%rip), %rdi    # 0x34690d
leaq 0x2abf3c(%rip), %rsi    # 0x346933
callq 0x107bfe
movq %rax, %rbx
leaq 0x30de0e(%rip), %rdi    # 0x3a8814
leaq 0x2abf62(%rip), %rsi    # 0x34696f
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x1(%r14), %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x8(%r14), %rdi
addq $0x10, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x10ad87
leaq 0xb1e74(%rip), %rsi     # 0x14c8c4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x107d3d
movq %rbx, %rdi
movl $0x1, %esi
movl $0x2, %edx
callq 0x10874b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1868f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_chseqids.c
// Function: gt_chseqids_runnter
static int gt_chseqids_runnter(GT_UNUSED int argc, const char **argv,
                               int parsed_args, void *tool_arguments,
                               GtError *err)
{
  ChseqidsArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream, *chseqids_stream, *sort_stream = NULL,
               *gff3_out_stream = NULL;
  GtStr *chseqids;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  /* create the streams */
  gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args + 1]);
  if (arguments->verbose && arguments->outfp)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);
  chseqids = gt_str_new_cstr(argv[parsed_args]);
  chseqids_stream = gt_chseqids_stream_new(gff3_in_stream, chseqids, err);
  if (!chseqids_stream)
    had_err = -1;
  gt_str_delete(chseqids);
  if (!had_err) {
    if (arguments->sort) {
      sort_stream = gt_sort_stream_new(chseqids_stream);
      gff3_out_stream = gt_gff3_out_stream_new(sort_stream, arguments->outfp);
    }
    else {
      gff3_out_stream = gt_gff3_out_stream_new(chseqids_stream,
                                               arguments->outfp);
    }
  }

  /* pull the features through the stream and free them afterwards */
  if (!had_err)
    had_err = gt_node_stream_pull(gff3_out_stream, err);

  /* free */
  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(chseqids_stream);
  gt_node_stream_delete(sort_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r12
testq %r8, %r8
je 0x9aaa7
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9ab84
testq %r15, %r15
je 0x9ab7f
movslq %ebx, %r13
movq 0x8(%r12,%r13,8), %rdi
callq 0x145d7c
movq %rax, %rbx
cmpb $0x1, 0x1(%r15)
jne 0x9aad6
cmpq $0x0, 0x10(%r15)
je 0x9aad6
movq %rbx, %rdi
callq 0x145b36
movq (%r12,%r13,8), %rdi
callq 0x11acc9
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x129105
movq %rax, %r12
movq %r13, %rdi
callq 0x11bdbf
testq %r12, %r12
je 0x9ab22
cmpb $0x1, (%r15)
jne 0x9ab2f
movq %r12, %rdi
callq 0x175d64
movq %rax, %r13
movq 0x10(%r15), %rsi
movq %rax, %rdi
callq 0x146fc0
movq %rax, %r15
jmp 0x9ab41
xorl %r13d, %r13d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
jmp 0x9ab4e
movq 0x10(%r15), %rsi
movq %r12, %rdi
callq 0x146fc0
movq %rax, %r15
xorl %r13d, %r13d
movq %r15, %rdi
movq %r14, %rsi
callq 0x162f5d
movl %eax, %ebp
movq %r15, %rdi
callq 0x162dee
movq %r12, %rdi
callq 0x162dee
movq %r13, %rdi
callq 0x162dee
movq %rbx, %rdi
callq 0x162dee
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x186fd
callq 0x186c6
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_clean.c
// Function: gt_clean_runner
int gt_clean_runner(GT_UNUSED int argc, GT_UNUSED const char **argv,
                    GT_UNUSED int parsed_args, GT_UNUSED void *tool_arguments,
                    GT_UNUSED GtError *err)
{
  gt_error_check(err);

#ifndef _WIN32
  remove_pattern_in_current_dir(GT_ENCSEQFILESUFFIX);
  remove_pattern_in_current_dir(GT_SSPTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_DESTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_SDSTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_OISTABFILESUFFIX);
  remove_pattern_in_current_dir(GT_MD5TABFILESUFFIX);
#else
  /* XXX */
  gt_error_set(err, "gt_clean_runner() not implemented");
  return -1;
#endif

  return 0;
}

// Assembly:
pushq %rax
testq %r8, %r8
je 0x9ab9e
movq %r8, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9abea
leaq 0x2abe76(%rip), %rdi    # 0x346a1b
callq 0x9abef
leaq 0x2abe6f(%rip), %rdi    # 0x346a20
callq 0x9abef
leaq 0x2abe68(%rip), %rdi    # 0x346a25
callq 0x9abef
leaq 0x2abe61(%rip), %rdi    # 0x346a2a
callq 0x9abef
leaq 0x2abe5a(%rip), %rdi    # 0x346a2f
callq 0x9abef
leaq 0x2abe53(%rip), %rdi    # 0x346a34
callq 0x9abef
xorl %eax, %eax
popq %rcx
retq
callq 0x18734
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_clean.c
// Function: remove_pattern_in_current_dir
static void remove_pattern_in_current_dir(const char *pattern)
{
  char **files_to_remove;
  GtStr *path;
  glob_t g;

  path = gt_str_new_cstr("./*");
  gt_str_append_cstr(path, pattern);
  gt_xglob(gt_str_get(path), GLOB_NOCHECK, NULL, &g);

  /* remove found files */
  if (g.gl_pathc) {
    files_to_remove = g.gl_pathv;
    if (strcmp(*files_to_remove, gt_str_get(path))) {
      while (*files_to_remove) {
        gt_xunlink(*files_to_remove);
        files_to_remove++;
      }
    }
  }

  /* free */
  globfree(&g);
  gt_str_delete(path);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
leaq 0x2abe37(%rip), %rdi    # 0x346a39
callq 0x11acc9
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x11acf3
movq %rbx, %rdi
callq 0x11b0a1
leaq 0x8(%rsp), %r14
movq %rax, %rdi
movl $0x10, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x11fb3d
cmpq $0x0, (%r14)
je 0x9ac76
movq 0x10(%rsp), %r15
movq (%r15), %r14
movq %rbx, %rdi
callq 0x11b0a1
movq %r14, %rdi
movq %rax, %rsi
callq 0x17a40
testl %eax, %eax
je 0x9ac76
movq (%r15), %rdi
testq %rdi, %rdi
je 0x9ac76
addq $0x8, %r15
callq 0x11fc3f
movq (%r15), %rdi
addq $0x8, %r15
testq %rdi, %rdi
jne 0x9ac65
leaq 0x8(%rsp), %rdi
callq 0x17500
movq %rbx, %rdi
callq 0x11bdbf
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads.c
// Function: gt_compreads_arguments_new
static void* gt_compreads_arguments_new(void)
{
  GtToolbox *compreads_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(compreads_toolbox,
      "refcompress", gt_compreads_refcompress());
  gt_toolbox_add_tool(compreads_toolbox,
      "refdecompress", gt_compreads_refdecompress());
  gt_toolbox_add_tool(compreads_toolbox,
      "compress", gt_compreads_compress());
  gt_toolbox_add_tool(compreads_toolbox,
      "decompress", gt_compreads_decompress());
  return compreads_toolbox;
}

// Assembly:
pushq %rbx
callq 0x11dc0a
movq %rax, %rbx
callq 0x9bb74
leaq 0x2abd62(%rip), %rsi    # 0x346a8e
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0x9c06c
leaq 0x2abd57(%rip), %rsi    # 0x346a9a
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0x9aeec
leaq 0x2abd45(%rip), %rsi    # 0x346a9f
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0x9b508
leaq 0x2abd2c(%rip), %rsi    # 0x346a9d
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads.c
// Function: gt_compreads_option_parser_new
static GtOptionParser* gt_compreads_option_parser_new(void *tool_arguments)
{
  GtToolbox *compreads_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(compreads_toolbox);
  op = gt_option_parser_new("[option ...] tool [argument ...]",
                            "Call a fastq file compression tool.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, compreads_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9add7
movq %rdi, %rbx
leaq 0x2abd54(%rip), %rdi    # 0x346af2
leaq 0x2abd6e(%rip), %rsi    # 0x346b13
callq 0x107bfe
movq %rax, %r14
leaq 0x82fea(%rip), %rsi     # 0x11dd9e
movq %rax, %rdi
movq %rbx, %rdx
callq 0x107d3d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1876b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads.c
// Function: gt_compreads_runner
static int gt_compreads_runner(GT_UNUSED int argc,
                         const char **argv,
                         int parsed_args,
                         void *tool_arguments, GtError *err)
{
  GtToolbox *compreads_toolbox = tool_arguments;
  GtToolfunc toolfunc;
  GtTool *tool = NULL;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(compreads_toolbox);
  if (!gt_toolbox_has_tool(compreads_toolbox, argv[parsed_args])) {
    gt_error_set(err, "compreads tool '%s' not found; option -help lists "
                      "possible tools", argv[parsed_args]);
    had_err = -1;
  }

  if (!had_err) {
    if (!(toolfunc = gt_toolbox_get(compreads_toolbox, argv[parsed_args]))) {
      tool = gt_toolbox_get_tool(compreads_toolbox, argv[parsed_args]);
      gt_assert(tool);
    }

    nargv = gt_cstr_array_prefix_first(argv + parsed_args,
                                       gt_error_get_progname(err));
    gt_error_set_progname(err, nargv[0]);
    if (toolfunc != NULL)
      had_err = toolfunc(argc - parsed_args, (const char**) nargv, err);
    else
      had_err = gt_tool_run(tool, argc - parsed_args, (const char**) nargv,
                            err);
  }
  gt_cstr_array_delete(nargv);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
movq %rsi, %r12
movl %edi, %ebp
testq %r8, %r8
je 0x9ae0a
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9aee2
testq %r15, %r15
je 0x9aedd
movslq %r14d, %r13
movq (%r12,%r13,8), %rsi
movq %r15, %rdi
callq 0x11dd07
movq (%r12,%r13,8), %rdx
testb %al, %al
je 0x9ae4b
leaq (%r12,%r13,8), %r13
movq %r15, %rdi
movq %rdx, %rsi
callq 0x11dd77
movq %rax, %r12
testq %rax, %rax
je 0x9ae66
movq $0x0, (%rsp)
jmp 0x9ae7b
leaq 0x2abcf9(%rip), %rsi    # 0x346b4b
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x9aec4
movq (%r13), %rsi
movq %r15, %rdi
callq 0x11dce1
movq %rax, (%rsp)
testq %rax, %rax
je 0x9aee7
movq %rbx, %rdi
callq 0xfccba
movq %r13, %rdi
movq %rax, %rsi
callq 0xe464a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xfcc72
subl %r14d, %ebp
testq %r12, %r12
je 0x9aeb1
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r12
jmp 0x9aec2
movq (%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x11d751
movl %eax, %ebx
movq %r15, %rdi
callq 0xe487c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x18810
callq 0x187a2
callq 0x187d9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads_compress.c
// Function: gt_compreads_compress_arguments_new
static void* gt_compreads_compress_arguments_new(void)
{
  GtCsrHcrEncodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->smap = gt_str_new();
  arguments->name = gt_str_new();
  arguments->files = gt_str_array_new();
  arguments->qrng.start = GT_UNDEF_UINT;
  arguments->qrng.end = GT_UNDEF_UINT;
  arguments->arg_range.start = GT_UNDEF_UWORD;
  arguments->arg_range.end = GT_UNDEF_UWORD;
  arguments->method = gt_str_new();
  arguments->pagewise = false;
  arguments->regular = false;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2abc70(%rip), %rdx    # 0x346b8c
movl $0x1, %edi
movl $0x48, %esi
movl $0x34, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
callq 0x11be10
movq %rax, 0x20(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x30(%rbx)
movq $-0x1, 0x40(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
movw $0x0, 0x1(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads_compress.c
// Function: gt_compreads_compress_arguments_delete
static void gt_compreads_compress_arguments_delete(void *tool_arguments)
{
  GtCsrHcrEncodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->name);
  gt_str_array_delete(arguments->files);
  gt_str_delete(arguments->smap);
  gt_str_delete(arguments->method);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9afb5
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x11bdbf
movq 0x20(%rbx), %rdi
callq 0x11c144
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
leaq 0x2abbe5(%rip), %rsi    # 0x346b8c
movq %rbx, %rdi
movl $0x4a, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads_decompress.c
// Function: gt_compreads_decompress_arguments_new
static void* gt_compreads_decompress_arguments_new(void)
{
  GtCsrHcrDecodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->file = gt_str_new();
  arguments->smap = gt_str_new();
  arguments->name = gt_str_new();
  arguments->rng.start = GT_UNDEF_UWORD;
  arguments->rng.end = GT_UNDEF_UWORD;
  arguments->bench = 0;

  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2abb2b(%rip), %rdx    # 0x34705e
movl $0x1, %edi
movl $0x48, %esi
movl $0x32, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x18(%rbx)
callq 0x11ac6c
movq %rax, 0x20(%rbx)
callq 0x11ac6c
movq %rax, 0x30(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x38(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads_decompress.c
// Function: gt_compreads_decompress_arguments_delete
static void gt_compreads_decompress_arguments_delete(void *tool_arguments)
{
  GtCsrHcrDecodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->file);
  gt_str_delete(arguments->name);
  gt_str_delete(arguments->smap);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9b5b4
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x11bdbf
movq 0x30(%rbx), %rdi
callq 0x11bdbf
movq 0x20(%rbx), %rdi
callq 0x11bdbf
leaq 0x2abab8(%rip), %rsi    # 0x34705e
movq %rbx, %rdi
movl $0x44, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads_refcompress.c
// Function: gt_compreads_refcompress_arguments_new
static void* gt_compreads_refcompress_arguments_new(void)
{
  GtCsrRcrEncodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->name = gt_str_new();
  arguments->ref = gt_str_new();
  arguments->align = gt_str_new();
  arguments->qrng.start = GT_UNDEF_UWORD;
  arguments->qrng.end = GT_UNDEF_UWORD;

  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2ab822(%rip), %rdx    # 0x3473c1
movl $0x1, %edi
movl $0x38, %esi
movl $0x35, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads_refcompress.c
// Function: gt_compreads_refcompress_arguments_delete
static void gt_compreads_refcompress_arguments_delete(void *tool_arguments)
{
  GtCsrRcrEncodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->name);
  gt_str_delete(arguments->ref);
  gt_str_delete(arguments->align);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9bc18
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
leaq 0x2ab7b7(%rip), %rsi    # 0x3473c1
movq %rbx, %rdi
movl $0x46, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads_refdecompress.c
// Function: gt_compreads_refdecompress_arguments_new
static void* gt_compreads_refdecompress_arguments_new(void)
{
  GtCsrRcrDecodeArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->file = gt_str_new();
  arguments->ref = gt_str_new();
  arguments->name = gt_str_new();

  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2ab6b7(%rip), %rdx    # 0x34774e
movl $0x1, %edi
movl $0x20, %esi
movl $0x2c, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads_refdecompress.c
// Function: gt_compreads_refdecompress_arguments_delete
static void gt_compreads_refdecompress_arguments_delete(void *tool_arguments)
{
  GtCsrRcrDecodeArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->file);
  gt_str_delete(arguments->name);
  gt_str_delete(arguments->ref);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x9c105
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
leaq 0x2ab657(%rip), %rsi    # 0x34774e
movq %rbx, %rdi
movl $0x3b, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_compreads_refdecompress.c
// Function: gt_compreads_refdecompress_option_parser_new
static GtOptionParser* gt_compreads_refdecompress_option_parser_new(
                                void *tool_arguments)
{
  GtCsrRcrDecodeArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] (-file file)",
                         "Decodes a given RCR (Reference Compressed Reads).");

  option = gt_option_new_bool("v", "be verbose",
                              &arguments->verbose, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_bool("qnames", "decode read names, default is "
                              "to just number them",
                              &arguments->qnames, false);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_string("ref", "Index file (generated by the gt encseq"
                                " tool) for reference genome.",
                                arguments->ref, NULL);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_string("rcr", "specify base name of file containing"
                                " RCR.",
                                arguments->file, NULL);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_string("name", "specify base name for decoded RCR"
                                " (suffix will be \".rcr.decoded\")",
                                arguments->name, NULL);
  gt_option_parser_add_option(op, option);

  gt_option_parser_set_min_max_args(op, 0U, 0U);
  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x9c20b
movq %rdi, %r14
leaq 0x2aaf8e(%rip), %rdi    # 0x3470ac
leaq 0x2ab67d(%rip), %rsi    # 0x3477a2
callq 0x107bfe
movq %rax, %rbx
leaq 0x18(%r14), %rdx
leaq 0x2f36fa(%rip), %rdi    # 0x38f832
leaq 0x2aafab(%rip), %rsi    # 0x3470ea
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x19(%r14), %rdx
leaq 0x2ab678(%rip), %rdi    # 0x3477d4
leaq 0x2ab678(%rip), %rsi    # 0x3477db
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x8(%r14), %rdx
leaq 0x2daeb8(%rip), %rdi    # 0x377038
leaq 0x2ab46f(%rip), %rsi    # 0x3475f6
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10a87b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq (%r14), %rdx
leaq 0x2f2cd2(%rip), %rdi    # 0x38ee80
leaq 0x2ab658(%rip), %rsi    # 0x34780d
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10a87b
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x10(%r14), %rdx
leaq 0x2e6582(%rip), %rdi    # 0x38275f
leaq 0x2ab653(%rip), %rsi    # 0x347837
xorl %ecx, %ecx
callq 0x10a770
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10874b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x18b98
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq.c
// Function: gt_condenseq_toolbox_new
static void* gt_condenseq_toolbox_new(void)
{
  GtToolbox *condenseq_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(condenseq_toolbox, "compress", gt_condenseq_compress());
  gt_toolbox_add_tool(condenseq_toolbox, "search", gt_condenseq_search());
  gt_toolbox_add_tool(condenseq_toolbox, "extract", gt_condenseq_extract());
  gt_toolbox_add_tool(condenseq_toolbox, "info", gt_condenseq_info());
  return condenseq_toolbox;
}

// Assembly:
pushq %rbx
callq 0x11dc0a
movq %rax, %rbx
callq 0x9e7a0
leaq 0x2aa067(%rip), %rsi    # 0x346a9f
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xa0c30
leaq 0x2ab6b9(%rip), %rsi    # 0x348108
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0x9f048
leaq 0x2af89e(%rip), %rsi    # 0x34c304
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
callq 0xa0664
leaq 0x2f6d00(%rip), %rsi    # 0x39377d
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq.c
// Function: gt_condenseq_option_parser_new
static GtOptionParser* gt_condenseq_option_parser_new(void *tool_arguments)
{
  GtToolbox *condenseq_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(condenseq_toolbox);

  /* init */
  op = gt_option_parser_new("tool [option ...]",
                            "Call one of the CONDENSER tools to prepare "
                            "or manipulate redundancy compressed genomic data."
                            );
  gt_option_parser_set_comment_func(op, gt_toolbox_show, condenseq_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x9cade
movq %rdi, %rbx
leaq 0x2ab198(%rip), %rdi    # 0x347c3d
leaq 0x2ab1a3(%rip), %rsi    # 0x347c4f
callq 0x107bfe
movq %rax, %r14
leaq 0x812e3(%rip), %rsi     # 0x11dd9e
movq %rax, %rdi
movq %rbx, %rdx
callq 0x107d3d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x18e01
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq.c
// Function: gt_condenseq_runner
static int gt_condenseq_runner(int argc, const char **argv, int parsed_args,
                               void *toolbox, GtError *err)
{
  GtToolbox *condenseq_toolbox = toolbox;
  GtTool *tool;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(condenseq_toolbox);

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

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

  /* free */
  gt_cstr_array_delete(nargv);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r14d
movq %rsi, %r12
movl %edi, %ebp
testq %r8, %r8
je 0x9cb11
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9cba8
testq %r15, %r15
je 0x9cba3
movslq %r14d, %rax
leaq (%r12,%rax,8), %r13
movq (%r13), %rsi
movq %r15, %rdi
callq 0x11dce1
testq %rax, %rax
je 0x9cb6d
movq %rax, %r12
movq %rbx, %rdi
callq 0xfccba
movq %r13, %rdi
movq %rax, %rsi
callq 0xe464a
movq %rax, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xfcc72
subl %r14d, %ebp
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x11d751
movl %eax, %ebx
jmp 0x9cb8a
movq (%r13), %rdx
leaq 0x2ab148(%rip), %rsi    # 0x347cc0
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0xe487c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x18e6f
callq 0x18e38
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_blast.c
// Function: gt_condenseq_blast_arguments_new
static void* gt_condenseq_blast_arguments_new(void)
{
  GtCondenseqBlastArguments *arguments =
    gt_calloc((size_t) 1, sizeof *arguments);
  arguments->csa = gt_condenseq_search_arguments_new();
  arguments->extraopts = gt_str_new();
  arguments->gff = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  arguments->querypath = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2ab148(%rip), %rdx    # 0x347d28
movl $0x1, %edi
movl $0x50, %esi
movl $0x6b, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x130cf8
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x28(%rbx)
callq 0x11ac6c
movq %rax, 0x20(%rbx)
callq 0x10ad60
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_blast.c
// Function: gt_condenseq_blast_arguments_delete
static void gt_condenseq_blast_arguments_delete(void *tool_arguments)
{
  GtCondenseqBlastArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_condenseq_search_arguments_delete(arguments->csa);
    gt_file_delete(arguments->outfp);
    gt_output_file_info_delete(arguments->ofi);
    gt_str_delete(arguments->extraopts);
    gt_str_delete(arguments->gff);
    gt_str_delete(arguments->querypath);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x9cc7c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x130d1f
movq (%rbx), %rdi
callq 0xff22c
movq 0x8(%rbx), %rdi
callq 0x10b00c
movq 0x28(%rbx), %rdi
callq 0x11bdbf
movq 0x20(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
leaq 0x2ab0ba(%rip), %rsi    # 0x347d28
movq %rbx, %rdi
movl $0x7e, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_blast.c
// Function: gt_condenseq_blast_arguments_check
static int gt_condenseq_blast_arguments_check(GT_UNUSED int rest_argc,
                                              void *tool_arguments,
                                              GT_UNUSED GtError *err)
{
  GtCondenseqBlastArguments *arguments = tool_arguments;
  int had_err = 0;
  if (!(arguments->blastn || arguments->blastp)) {
    gt_error_set(err, "no other searches then blast implemented yet, please "
                 "provide either -blastn or -blastp");
    had_err = -1;
  }
  gt_error_check(err);
  gt_assert(arguments);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorl %ebp, %ebp
cmpb $0x0, 0x4d(%rsi)
jne 0x9cef4
cmpb $0x0, 0x4c(%rsi)
jne 0x9cef4
leaq 0x2ab113(%rip), %rsi    # 0x347ff8
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x9cf05
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9cf0e
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x18edf
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_blast.c
// Function: gt_ces_blast_range_compare
static int gt_ces_blast_range_compare(const void *a, const void *b,
                                      GT_UNUSED void* data)
{
  const HitRange *rangeA = a,
        *rangeB = b;
  gt_assert(data == NULL);

  if (rangeA->seqid < rangeB->seqid)
    return -1;
  if (rangeA->seqid > rangeB->seqid)
    return 1;
  if (rangeA->range.start < rangeB->range.start)
    return -1;
  if (rangeA->range.start > rangeB->range.start)
    return 1;
  if (rangeA->range.end < rangeB->range.end)
    return -1;
  if (rangeA->range.end > rangeB->range.end)
    return 1;
  return 0;
}

// Assembly:
testq %rdx, %rdx
jne 0x9e6d2
movq 0x10(%rsi), %rax
cmpq %rax, 0x10(%rdi)
jae 0x9e6aa
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl $0x1, %eax
jbe 0x9e6b2
retq
movq (%rsi), %rcx
cmpq %rcx, (%rdi)
jb 0x9e6a4
ja 0x9e6b1
movq 0x8(%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rcx, 0x8(%rdi)
jb 0x9e6b1
seta %al
movzbl %al, %eax
retq
pushq %rax
callq 0x190e0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_blast.c
// Function: gt_condenseq_blast_process_hit
static int gt_condenseq_blast_process_hit(void *data,
                                          GtUword seqid,
                                          GtRange seqrange,
                                          GT_UNUSED GtError *err)
{
  GtCondenseqBlastPrintHitInfo *info =
    (GtCondenseqBlastPrintHitInfo *) data;
  bool nodecreated;
  HitRange *key = gt_malloc(sizeof(*key));

  gt_error_check(err);

  key->range = seqrange;
  key->seqid = seqid;
  key = gt_rbtree_search(info->to_extract_rbt, key, &nodecreated);
  if (!nodecreated)
    gt_free(key);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0x2a961e(%rip), %rsi    # 0x347d28
movl $0x18, %edi
movl $0x15d, %edx            # imm = 0x15D
callq 0x104226
movq %rax, %r13
testq %rbp, %rbp
je 0x9e72d
movq %rbp, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9e777
movq %r12, (%r13)
movq %rbx, 0x8(%r13)
movq %r15, 0x10(%r13)
movq 0x20(%r14), %rdi
leaq 0x7(%rsp), %rbx
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1663b6
cmpb $0x0, (%rbx)
jne 0x9e766
leaq 0x2a95cf(%rip), %rsi    # 0x347d28
movq %rax, %rdi
movl $0x165, %edx            # imm = 0x165
callq 0x1045eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x19119
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_blast.c
// Function: gt_condenseq_avg_helper
static inline int gt_condenseq_avg_helper(GtUword current_len,
                                          void *data,
                                          GT_UNUSED GtError *err)
{
  GtCondenseqBlastQInfo *qinfo = (GtCondenseqBlastQInfo *) data;
  qinfo->avg += current_len;
  qinfo->count++;
  gt_assert(qinfo->avg >= current_len);
  qinfo->max = qinfo->max < current_len ? current_len : qinfo->max;
  return 0;
}

// Assembly:
incq 0x10(%rsi)
addq %rdi, (%rsi)
jb 0x9e797
movq 0x8(%rsi), %rax
cmpq %rdi, %rax
cmovaq %rax, %rdi
movq %rdi, 0x8(%rsi)
xorl %eax, %eax
retq
pushq %rax
callq 0x19152
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_compress.c
// Function: gt_condenseq_compress_arguments_new
static void* gt_condenseq_compress_arguments_new(void)
{
  GtCondenseqCompressArguments *arguments = gt_calloc((size_t) 1,
                                                      sizeof *arguments);
  arguments->indexname = gt_str_new();
  arguments->input_es = NULL;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a9d98(%rip), %rdx    # 0x348568
movl $0x1, %edi
movl $0x60, %esi
movl $0x39, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x8(%rbx)
movq $0x0, (%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_compress.c
// Function: gt_condenseq_compress_arguments_delete
static void gt_condenseq_compress_arguments_delete(void *tool_arguments)
{
  GtCondenseqCompressArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_delete(arguments->indexname);
    gt_encseq_delete(arguments->input_es);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x9e82b
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x11bdbf
movq (%rbx), %rdi
callq 0xea375
leaq 0x2a9d4b(%rip), %rsi    # 0x348568
movq %rbx, %rdi
movl $0x45, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_compress.c
// Function: gt_condenseq_compress_arguments_check
static int gt_condenseq_compress_arguments_check(int rest_argc,
                                                 void *tool_arguments,
                                                 GtError *err)
{
  GT_UNUSED GtCondenseqCompressArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (rest_argc != 1) {
    gt_error_set(err, "give the basename of an encseq as minimum arguments");
    had_err = -1;
  }
  if (arguments->clean_percent != GT_UNDEF_UINT &&
      arguments->clean_percent > 100U) {
    gt_error_set(err, "'-diags_clean' expects an integer argument between 0 "
                 "and 100 ");
    had_err = -1;
  }
  if (arguments->brute && (arguments->diags || arguments->full_diags)) {
    gt_error_set(err, "'-brute_force' is not compatible with '-diagonals' or "
                 "'-full_diags'");
    had_err = -1;
  }
  if (arguments->cutoff_value == 0 && arguments->prune) {
    gt_error_set(err, "'-cutoff 0' disables cutoffs, so '-disable_prune' should"
                 " not be set.");
    had_err = -1;
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0x9ebf9
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9ec9a
testq %r14, %r14
je 0x9ec95
xorl %eax, %eax
cmpl $0x1, %ebp
je 0x9ec1f
leaq 0x2aa083(%rip), %rsi    # 0x348c93
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl 0x50(%r14), %ecx
addl $-0x65, %ecx
cmpl $-0x67, %ecx
ja 0x9ec41
leaq 0x2aa095(%rip), %rsi    # 0x348cc7
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, 0x56(%r14)
jne 0x9ec6c
cmpb $0x0, 0x54(%r14)
jne 0x9ec56
cmpb $0x1, 0x55(%r14)
jne 0x9ec6c
leaq 0x2aa0a8(%rip), %rsi    # 0x348d05
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x0, 0x28(%r14)
jne 0x9ec90
cmpb $0x1, 0x59(%r14)
jne 0x9ec90
leaq 0x2aa0c8(%rip), %rsi    # 0x348d49
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
callq 0x191fb
callq 0x191c2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_extract.c
// Function: gt_condenseq_extract_arguments_new
static void* gt_condenseq_extract_arguments_new(void)
{
  GtCondenserExtractArguments *arguments = gt_calloc((size_t) 1,
                                                     sizeof *arguments);
  arguments->range.start =
    arguments->range.end = GT_UNDEF_UWORD;
  arguments->seqrange.start =
    arguments->seqrange.end = GT_UNDEF_UWORD;
  arguments->ofi = gt_output_file_info_new();
  arguments->mode = gt_str_new();
  arguments->sepchar = gt_str_new();
  arguments->sepchar_opt = NULL;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a9e0b(%rip), %rdx    # 0x348e83
movl $0x1, %edi
movl $0x60, %esi
movl $0x33, %ecx
callq 0x10436a
movq %rax, %rbx
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x28(%rax)
movdqu %xmm0, 0x38(%rax)
callq 0x10ad60
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_extract.c
// Function: gt_condenseq_extract_arguments_delete
static void gt_condenseq_extract_arguments_delete(void *tool_arguments)
{
  GtCondenserExtractArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_file_delete(arguments->outfp);
    gt_output_file_info_delete(arguments->ofi);
    gt_str_delete(arguments->mode);
    gt_str_delete(arguments->sepchar);
    gt_option_delete(arguments->sepchar_opt);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x9f10f
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xff22c
movq 0x8(%rbx), %rdi
callq 0x10b00c
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq 0x20(%rbx), %rdi
callq 0x10a16a
leaq 0x2a9d82(%rip), %rsi    # 0x348e83
movq %rbx, %rdi
movl $0x48, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_extract.c
// Function: gt_condenseq_extract_arguments_check
static int gt_condenseq_extract_arguments_check(int rest_argc,
                                                void *tool_arguments,
                                                GtError *err)
{
  GtCondenserExtractArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (rest_argc != 1) {
    had_err = -1;
    gt_error_set(err, "archive parameter is mandatory, use -help for usage");
  }
  if (!had_err &&
      arguments->range.start != GT_UNDEF_UWORD) {
    if (arguments->range.start > arguments->range.end) {
      had_err = -1;
      gt_error_set(err, "give range of positions in the form 'a b' with a "
                   "<= b");
    }
    if (!had_err &&
        strcmp(gt_str_get(arguments->mode), "fasta") == 0) {
      had_err = -1;
      gt_error_set(err, "-range is incompatible to fasta output");
    }
  }
  if (!had_err &&
      arguments->seqrange.start != GT_UNDEF_UWORD) {
    if (arguments->seqrange.start > arguments->seqrange.end) {
      had_err = -1;
      gt_error_set(err, "give range of positions in the form 'a b' with a "
                   "<= b");
    }
  }

  if (!had_err &&
      gt_option_is_set(arguments->sepchar_opt)) {
    if (strcmp(gt_str_get(arguments->mode), "fasta") == 0) {
      had_err = -1;
      gt_error_set(err, "-sepchar is incompatible with -output fasta");
    }
    if (!had_err &&
        gt_str_length(arguments->sepchar) != (GtUword) 1) {
      had_err = -1;
      gt_error_set(err, "sepchar (\"%s\" given) has to be a single character",
                   gt_str_get(arguments->sepchar));
    }
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0x9f2d4
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9f3bb
testq %r14, %r14
je 0x9f3b6
cmpl $0x1, %ebp
jne 0x9f32b
movq 0x28(%r14), %rax
cmpq $-0x1, %rax
je 0x9f312
cmpq 0x30(%r14), %rax
ja 0x9f322
movq 0x10(%r14), %rdi
callq 0x11b0a1
leaq 0x2da80e(%rip), %rsi    # 0x379b10
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0x9f3a1
movq 0x38(%r14), %rax
cmpq $-0x1, %rax
je 0x9f348
cmpq 0x40(%r14), %rax
jbe 0x9f348
leaq 0x2a9dbf(%rip), %rsi    # 0x3490e8
jmp 0x9f332
leaq 0x2a9d82(%rip), %rsi    # 0x3490b4
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x20(%r14), %rdi
callq 0x10ac3f
xorl %ebp, %ebp
testb %al, %al
je 0x9f341
movq 0x10(%r14), %rdi
callq 0x11b0a1
leaq 0x2da7a9(%rip), %rsi    # 0x379b10
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0x9f3aa
movq 0x18(%r14), %rdi
callq 0x11b0ca
cmpq $0x1, %rax
je 0x9f341
movq 0x18(%r14), %rdi
callq 0x11b0a1
leaq 0x2a9ddf(%rip), %rsi    # 0x349171
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
jmp 0x9f33c
leaq 0x2a9d76(%rip), %rsi    # 0x34911e
jmp 0x9f332
leaq 0x2a9d94(%rip), %rsi    # 0x349145
jmp 0x9f332
callq 0x19343
callq 0x1930a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_hmmsearch.c
// Function: gt_condenseq_hmmsearch_arguments_new
static void* gt_condenseq_hmmsearch_arguments_new(void)
{
  GtCondenseqHmmsearchArguments *arguments =
    gt_calloc((size_t) 1, sizeof *arguments);
  arguments->csa = gt_condenseq_search_arguments_new();
  arguments->hmm = gt_str_new();
  arguments->hmmsearch_path = gt_str_new();
  arguments->outtable_filename = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2a9ac4(%rip), %rdx    # 0x3492bc
movl $0x1, %edi
movl $0x30, %esi
movl $0x3c, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x130cf8
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_hmmsearch.c
// Function: gt_condenseq_hmmsearch_arguments_delete
static void gt_condenseq_hmmsearch_arguments_delete(void *tool_arguments)
{
  GtCondenseqHmmsearchArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_condenseq_search_arguments_delete(arguments->csa);
    gt_str_delete(arguments->hmm);
    gt_str_delete(arguments->hmmsearch_path);
    gt_str_delete(arguments->outtable_filename);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x9f878
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x130d1f
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
leaq 0x2a9a52(%rip), %rsi    # 0x3492bc
movq %rbx, %rdi
movl $0x4c, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_hmmsearch.c
// Function: gt_condenseq_hmmsearch_arguments_check
static int gt_condenseq_hmmsearch_arguments_check(int rest_argc,
                                                  void *tool_arguments,
                                                  GtError *err)
{
  GtCondenseqHmmsearchArguments GT_UNUSED *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (rest_argc != 0) {
    gt_error_set(err, "to many arguments use -help for options");
    had_err = -1;
  }
  if (!had_err) {
    struct stat buf;
    if (stat(gt_str_get(arguments->hmmsearch_path), &buf) != 0) {
      gt_error_set(err, "error with %s: %s",
                   gt_str_get(arguments->hmmsearch_path),
                   strerror(errno));
      had_err = -1;
    }
    if (!had_err) {
      mode_t mode = buf.st_mode & S_IRWXU;
      if (!(mode & S_IXUSR)    /* owner executable */
#ifndef _WIN32
          && !(mode & S_IXGRP) /* group ~ */
          && !(mode & S_IXOTH) /* other ~ */
#endif
         ) {
        gt_error_set(err, "%s is not executable",
                     gt_str_get(arguments->hmmsearch_path));
        had_err = -1;
      }
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0x9f9d2
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x9fa77
testq %r14, %r14
je 0x9fa72
testl %ebp, %ebp
je 0x9f9f2
leaq 0x2a9b92(%rip), %rsi    # 0x349578
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
jmp 0x9fa61
movq 0x10(%r14), %rdi
callq 0x11b0a1
movq %rsp, %rsi
movq %rax, %rdi
callq 0x18000
testl %eax, %eax
je 0x9fa3b
movq 0x10(%r14), %rdi
callq 0x11b0a1
movq %rax, %r14
callq 0x17060
movl (%rax), %edi
callq 0x17240
leaq 0x2a9b77(%rip), %rsi    # 0x3495a0
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0xfcb67
jmp 0x9fa61
xorl %eax, %eax
testb $0x40, 0x18(%rsp)
jne 0x9fa66
movq 0x10(%r14), %rdi
callq 0x11b0a1
leaq 0x2a9b5e(%rip), %rsi    # 0x3495b2
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x194d0
callq 0x19497
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_hmmsearch.c
// Function: hmmsearch_create_fine_fas
static void hmmsearch_create_fine_fas(GtStr *fine_fasta_filename,
                                      GtRBTree *seqnums,
                                      GtCondenseq *ces) {
  GtRBTreeIter *tree_iter;
  GtUword *seqnum;
  GtFile *gt_outfp;
  FILE *outfp;

  tree_iter = gt_rbtree_iter_new_from_first(seqnums);
  outfp = gt_xtmpfp_generic(fine_fasta_filename, GT_TMPFP_USETEMPLATE);
  gt_outfp = gt_file_new_from_fileptr(outfp);
  seqnum = gt_rbtree_iter_data(tree_iter);
  while (seqnum != NULL) {
    const char *seq, *desc;
    GtUword seqlen, desclen;
    seq = gt_condenseq_extract_decoded(ces, &seqlen, *seqnum);
    desc = gt_condenseq_description(ces, &desclen, *seqnum);
    gt_fasta_show_entry_nt(desc, desclen, seq, seqlen,
                           GT_FASTA_DEFAULT_WIDTH, gt_outfp);
    seqnum = gt_rbtree_iter_next(tree_iter);
  }
  gt_file_delete(gt_outfp);
  gt_rbtree_iter_delete(tree_iter);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x166d2a
movq %rax, %r14
leaq 0x2a8ee9(%rip), %rdx    # 0x3492bc
movq %r15, %rdi
movl $0x2, %esi
movl $0xdb, %ecx
callq 0xfd35a
movq %rax, %rdi
callq 0xfed85
movq %rax, %r15
movq %r14, %rdi
callq 0x166ff0
testq %rax, %rax
je 0xa0456
movq %rax, %rbp
leaq 0x8(%rsp), %r13
movq (%rbp), %rdx
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x12d638
movq %rax, %r12
movq (%rbp), %rdx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x12bb9d
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
movl $0x50, %r8d
movq %rax, %rdi
movq %r12, %rdx
movq %r15, %r9
callq 0xfe0d0
movq %r14, %rdi
callq 0x166ea4
movq %rax, %rbp
testq %rax, %rax
jne 0xa0405
movq %r15, %rdi
callq 0xff22c
movq %r14, %rdi
callq 0x16700c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_condenseq_hmmsearch.c
// Function: hmmsearch_process_seq
static int hmmsearch_process_seq(void *data,
                                 GtUword seqnum,
                                 GT_UNUSED GtError *err)
{
  int had_err = 0;
  bool nodecreated = false;
  GtUword *seqnum_p = gt_malloc(sizeof (*seqnum_p));
  GtRBTree *tree = data;
  *seqnum_p = seqnum;
  (void) gt_rbtree_search(tree,
                          seqnum_p,
                          &nodecreated);
  if (!nodecreated)
    gt_free(seqnum_p);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x7(%rsp), %r12
movb $0x0, (%r12)
leaq 0x2a8ca4(%rip), %rsi    # 0x3492bc
movl $0x8, %edi
movl $0xbb, %edx
callq 0x104226
movq %rax, %rbx
movq %r14, (%rax)
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1663b6
cmpb $0x0, (%r12)
jne 0xa0656
leaq 0x2a8c73(%rip), %rsi    # 0x3492bc
movq %rbx, %rdi
movl $0xc2, %edx
callq 0x1045eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq