LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_speck.c
// Function: gt_speck_arguments_delete
static void gt_speck_arguments_delete(void *tool_arguments)
{
  SpeccheckArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->specfile);
  gt_str_delete(arguments->format);
  gt_file_delete(arguments->outfp);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_output_file_info_delete(arguments->ofi);
  gt_typecheck_info_delete(arguments->tci);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xcc4e3
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq 0x30(%rbx), %rdi
callq 0xff22c
movq 0x18(%rbx), %rdi
callq 0x172c87
movq 0x20(%rbx), %rdi
callq 0x10b00c
movq 0x28(%rbx), %rdi
callq 0x1832d8
leaq 0x28f43e(%rip), %rsi    # 0x35b913
movq %rbx, %rdi
movl $0x4c, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_speck.c
// Function: gt_speck_arguments_check
static int gt_speck_arguments_check(GT_UNUSED int rest_argc,
                                    void *tool_arguments,
                                    GT_UNUSED GtError *err)
{
  SpeccheckArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if ((arguments->outfp || (!arguments->outfp && !isatty(STDOUT_FILENO)))
      && arguments->colored) {
    gt_warning("not printing to terminal, disabling colored output");
    arguments->colored = false;
  }

  return had_err = 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0xcc652
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xcc68f
testq %rbx, %rbx
je 0xcc68a
cmpq $0x0, 0x30(%rbx)
je 0xcc678
cmpb $0x1, 0x11(%rbx)
jne 0xcc686
leaq 0x28f4b7(%rip), %rdi    # 0x35bb22
xorl %eax, %eax
callq 0x11f68c
movb $0x0, 0x11(%rbx)
jmp 0xcc686
movl $0x1, %edi
callq 0x17d80
testl %eax, %eax
je 0xcc65e
xorl %eax, %eax
popq %rbx
retq
callq 0x20e9e
callq 0x20e65
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_speck.c
// Function: gt_speck_record_warning
static void gt_speck_record_warning(void *data, const char *format, va_list ap)
{
  char buf[BUFSIZ];
  gt_assert(data && format);
  (void) vsnprintf(buf, (BUFSIZ * sizeof (char)), format, ap);
  gt_spec_results_record_warning((GtSpecResults*) data, buf);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
testq %rdi, %rdi
je 0xccc8b
movq %rdx, %rcx
movq %rsi, %rdx
testq %rsi, %rsi
je 0xccc8b
movq %rdi, %rbx
movq %rsp, %r14
movl $0x2000, %esi           # imm = 0x2000
movq %r14, %rdi
callq 0x17480
movq %rbx, %rdi
movq %r14, %rsi
callq 0x175eb5
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %r14
retq
callq 0x21066
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_splicesiteinfo.c
// Function: gt_splicesiteinfo_arguments_new
static void* gt_splicesiteinfo_arguments_new(void)
{
  SpliceSiteInfoArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x28ef18(%rip), %rdx    # 0x35bbd3
movl $0x1, %edi
movl $0x20, %esi
movl $0x28, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x172c40
movq %rax, 0x8(%rbx)
callq 0x10ad60
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_splicesiteinfo.c
// Function: gt_splicesiteinfo_arguments_delete
static void gt_splicesiteinfo_arguments_delete(void *tool_arguments)
{
  SpliceSiteInfoArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xccd22
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff22c
movq 0x10(%rbx), %rdi
callq 0x10b00c
movq 0x8(%rbx), %rdi
callq 0x172c87
leaq 0x28eebf(%rip), %rsi    # 0x35bbd3
movq %rbx, %rdi
movl $0x35, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_splicesiteinfo.c
// Function: gt_splicesiteinfo_option_parser_new
static GtOptionParser* gt_splicesiteinfo_option_parser_new(void *tool_arguments)
{
  SpliceSiteInfoArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Show information "
                            "about splice sites given in GFF3 files.");

  /* -seqfile, -matchdesc, -usedesc and -regionmapping */
  gt_seqid2file_register_options(op, arguments->s2fi);

  /* -addintrons */
  option = gt_option_new_bool("addintrons", "add intron features between "
                              "existing exon features\n(before computing the "
                              "information to be shown)",
                              &arguments->addintrons, false);
  gt_option_parser_add_option(op, option);

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

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xccda3
movq %rdi, %rbx
leaq 0x27d7c3(%rip), %rdi    # 0x34a4f9
leaq 0x28eed8(%rip), %rsi    # 0x35bc15
callq 0x107bfe
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x172f86
leaq 0x281139(%rip), %rdi    # 0x34de91
leaq 0x28eeef(%rip), %rsi    # 0x35bc4e
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ad87
leaq 0x7fb36(%rip), %rsi     # 0x14c8c4
movq %r14, %rdi
xorl %edx, %edx
callq 0x107d3d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2109f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_stat.c
// Function: gt_stat_arguments_delete
static void gt_stat_arguments_delete(void *tool_arguments)
{
  StatArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xcd654
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xff22c
movq 0x10(%rbx), %rdi
callq 0x10b00c
leaq 0x28e90c(%rip), %rsi    # 0x35bf52
movq %rbx, %rdi
movl $0x37, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_stat.c
// Function: gt_stat_runner
static int gt_stat_runner(int argc, const char **argv, int parsed_args,
                          void *tool_arguments, GtError *err)
{
  StatArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream, *sort_stream, *add_introns_stream = NULL,
               *stat_stream;
  int had_err;
  gt_error_check(err);

  /* create a gff3 input stream */
  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
                                                  argv + parsed_args);
  if (arguments->verbose)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);

  /* create add introns stream if -addintrons was used */
  if (arguments->addintrons) {
    sort_stream = gt_sort_stream_new(gff3_in_stream);
    add_introns_stream = gt_add_introns_stream_new(sort_stream);
  }

  /* create stat stream */
  stat_stream = gt_stat_stream_new(arguments->addintrons
                                   ? add_introns_stream : gff3_in_stream,
                                   arguments->gene_length_distribution,
                                   arguments->gene_score_distribution,
                                   arguments->exon_length_distribution,
                                   arguments->exon_number_distribution,
                                   arguments->intron_length_distribution,
                                   arguments->cds_length_distribution,
                                   arguments->used_sources);

  /* pull the features through the stream , compute the statistics, and free
     them afterwards */
  had_err = gt_node_stream_pull(stat_stream, err);

  /* show statistics */
  if (!had_err)
    gt_stat_stream_show_stats((GtStatStream*) stat_stream, arguments->outfp);

  /* free */
  gt_node_stream_delete(stat_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %r12d
movq %rsi, %r15
movl %edi, %ebp
testq %r8, %r8
je 0xcd7ee
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0xcd899
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r15,%rax,8), %rsi
movl %ebp, %edi
callq 0x145cdf
movq %rax, %r15
cmpb $0x1, 0x8(%rbx)
jne 0xcd810
movq %r15, %rdi
callq 0x145b36
cmpb $0x1, 0x7(%rbx)
movq %r15, %rdi
jne 0xcd834
movq %r15, %rdi
callq 0x175d64
movq %rax, %rdi
callq 0x120894
testb $0x1, 0x7(%rbx)
movq %r15, %rdi
cmovneq %rax, %rdi
movzbl (%rbx), %esi
movzbl 0x1(%rbx), %edx
movzbl 0x3(%rbx), %ecx
movzbl 0x2(%rbx), %r8d
movzbl 0x4(%rbx), %r9d
movzbl 0x5(%rbx), %eax
movzbl 0x6(%rbx), %r10d
pushq %r10
pushq %rax
callq 0x17a740
addq $0x10, %rsp
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x162f5d
movl %eax, %ebp
testl %eax, %eax
jne 0xcd87e
movq 0x18(%rbx), %rsi
movq %r12, %rdi
callq 0x17a7d0
movq %r12, %rdi
callq 0x162dee
movq %r15, %rdi
callq 0x162dee
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x213af
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tagerator.c
// Function: gt_tagerator_arguments_new
static void *gt_tagerator_arguments_new(void)
{
  TageratorOptions *arguments;

  arguments = gt_malloc(sizeof (TageratorOptions));
  arguments->indexname = gt_str_new();
  arguments->tagfiles = gt_str_array_new();
  arguments->outputspec = gt_str_array_new();
  arguments->outputmode = 0;
  arguments->numberofmodedescentries = sizeof (outputmodedesctable)/
                                       sizeof (outputmodedesctable[0]);
  arguments->outputhelp
    = gt_getargmodekeywords(outputmodedesctable,
                            arguments->numberofmodedescentries,
                            "output");
  arguments->modedesc = outputmodedesctable;
  return arguments;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x28e890(%rip), %rsi    # 0x35c19b
movl $0x68, %edi
movl $0x30, %edx
callq 0x104226
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11be10
movq %rax, (%rbx)
callq 0x11be10
movq %rax, 0x8(%rbx)
movl $0x0, 0x54(%rbx)
movq $0xb, 0x60(%rbx)
leaq 0x3e5c03(%rip), %r14    # 0x4b3550
leaq 0x29e6d3(%rip), %rdx    # 0x36c027
movl $0xb, %esi
movq %r14, %rdi
callq 0x1b7f9d
movq %rax, 0x18(%rbx)
movq %r14, 0x30(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tagerator.c
// Function: gt_tagerator_arguments_delete
static void gt_tagerator_arguments_delete(void *tool_arguments)
{
  TageratorOptions *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->indexname);
  gt_str_delete(arguments->outputhelp);
  gt_str_array_delete(arguments->tagfiles);
  gt_str_array_delete(arguments->outputspec);
  gt_option_delete(arguments->refoptionesaindex);
  gt_option_delete(arguments->refoptionpckindex);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xcd9c7
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq (%rbx), %rdi
callq 0x11c144
movq 0x8(%rbx), %rdi
callq 0x11c144
movq 0x20(%rbx), %rdi
callq 0x10a16a
movq 0x28(%rbx), %rdi
callq 0x10a16a
leaq 0x28e7e2(%rip), %rsi    # 0x35c19b
movq %rbx, %rdi
movl $0x4d, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_arguments_new
static void *gt_tyr_arguments_new(void)
{
  GtToolbox *tyr_toolbox = gt_toolbox_new();
  gt_toolbox_add_tool(tyr_toolbox, "mkindex", gt_tyr_mkindex());
  gt_toolbox_add_tool(tyr_toolbox, "occratio", gt_tyr_occratio());
  gt_toolbox_add_tool(tyr_toolbox, "search", gt_tyr_search());
  return tyr_toolbox;
}

// Assembly:
pushq %rbx
callq 0x11dc0a
movq %rax, %rbx
leaq 0x21f(%rip), %rdi       # 0xce1f6
leaq 0x249(%rip), %rsi       # 0xce227
leaq 0x27c(%rip), %rdx       # 0xce261
leaq 0x485(%rip), %rcx       # 0xce471
leaq 0x4da(%rip), %r8        # 0xce4cd
callq 0x11d6d0
leaq 0x2833f7(%rip), %rsi    # 0x3513f6
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
leaq 0x6b0(%rip), %rdi       # 0xce6c1
leaq 0x6f1(%rip), %rsi       # 0xce709
leaq 0x749(%rip), %rdx       # 0xce768
leaq 0x8ee(%rip), %rcx       # 0xce914
leaq 0xc1e(%rip), %r8        # 0xcec4b
callq 0x11d6d0
leaq 0x28e781(%rip), %rsi    # 0x35c7ba
movq %rbx, %rdi
movq %rax, %rdx
callq 0x11dc3f
leaq 0xfc3(%rip), %rdi       # 0xcf00e
leaq 0x1006(%rip), %rsi      # 0xcf058
leaq 0x1041(%rip), %rdx      # 0xcf09a
leaq 0x115c(%rip), %rcx      # 0xcf1bc
leaq 0x1252(%rip), %r8       # 0xcf2b9
callq 0x11d6d0
leaq 0x27a095(%rip), %rsi    # 0x348108
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_tallymer.c
// Function: gt_tyr_option_parser_new
static GtOptionParser* gt_tyr_option_parser_new(void *tool_arguments)
{
  GtToolbox *index_toolbox = tool_arguments;
  GtOptionParser *op;

  gt_assert(index_toolbox != NULL);
  op = gt_option_parser_new(
                    "[option ...] tallymer_tool [argument ...]",
                    "Call a tallymer 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, 1U);
  gt_option_parser_refer_to_manual(op);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xce0e1
movq %rdi, %rbx
leaq 0x28f1e7(%rip), %rdi    # 0x35d287
leaq 0x28f20a(%rip), %rsi    # 0x35d2b1
callq 0x107bfe
movq %rax, %r14
leaq 0x4fce8(%rip), %rsi     # 0x11dd9e
movq %rax, %rdi
movq %rbx, %rdx
callq 0x107d3d
movq %r14, %rdi
movl $0x1, %esi
callq 0x10872d
movq %r14, %rdi
callq 0x107d2d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x2153a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_mkindex_arguments_new
static void *gt_tyr_mkindex_arguments_new(void)
{
  Tyr_mkindex_options *arguments
    = gt_malloc(sizeof (Tyr_mkindex_options));
  arguments->str_storeindex = gt_str_new();
  arguments->str_inputindex = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x28e5c5(%rip), %rsi    # 0x35c7c3
movl $0x48, %edi
movl $0x48, %edx
callq 0x104226
movq %rax, %rbx
callq 0x11ac6c
movq %rax, 0x30(%rbx)
callq 0x11ac6c
movq %rax, 0x38(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_mkindex_arguments_delete
static void gt_tyr_mkindex_arguments_delete(void *tool_arguments)
{
  Tyr_mkindex_options *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->str_storeindex);
  gt_str_delete(arguments->str_inputindex);
  gt_option_delete(arguments->refoptionpl);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xce260
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x11bdbf
movq 0x28(%rbx), %rdi
callq 0x10a16a
leaq 0x28e571(%rip), %rsi    # 0x35c7c3
movq %rbx, %rdi
movl $0x59, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_occratio_arguments_new
static void *gt_tyr_occratio_arguments_new(void)
{
  Tyr_occratio_options *arguments
    = gt_malloc(sizeof (Tyr_occratio_options));
  arguments->mersizesstrings = gt_str_array_new();
  arguments->outputspec = gt_str_array_new();
  arguments->str_inputindex = gt_str_new();
  arguments->outputvector = NULL;
  arguments->outputmode = 0;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x28e0fa(%rip), %rsi    # 0x35c7c3
movl $0x48, %edi
movl $0x142, %edx            # imm = 0x142
callq 0x104226
movq %rax, %rbx
callq 0x11be10
movq %rax, (%rbx)
callq 0x11be10
movq %rax, 0x8(%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
movq $0x0, 0x38(%rbx)
movl $0x0, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_occratio_arguments_delete
static void gt_tyr_occratio_arguments_delete(void *tool_arguments)
{
  Tyr_occratio_options *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_array_delete(arguments->mersizesstrings);
  gt_str_array_delete(arguments->outputspec);
  gt_str_delete(arguments->str_inputindex);
  gt_option_delete(arguments->refoptionmersizes);
  gt_free(arguments->outputvector);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xce767
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11c144
movq 0x8(%rbx), %rdi
callq 0x11c144
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x10a16a
movq 0x38(%rbx), %rdi
leaq 0x28e080(%rip), %r14    # 0x35c7c3
movq %r14, %rsi
movl $0x157, %edx            # imm = 0x157
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x158, %edx            # imm = 0x158
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: showitvdistribution
static void showitvdistribution(const GtArrayuint64_t *dist,
                                const GtBitsequence *outputvector)
{
  GtUword idx;

  gt_assert(outputvector != NULL);
  for (idx=0; idx < dist->nextfreeuint64_t; idx++)
  {
    if (GT_ISIBITSET(outputvector,idx) && dist->spaceuint64_t[idx] > 0)
    {
      /*@ignore@*/
      printf(""GT_WU" " Formatuint64_t "\n",
              idx,
              PRINTuint64_tcast(dist->spaceuint64_t[idx]));
      /*@end@*/
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xcf009
movq %rdi, %r14
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0xceffd
movq %rsi, %rbx
leaq 0x2b2e2f(%rip), %r15    # 0x381ded
xorl %r12d, %r12d
movq %r12, %rcx
shrq $0x6, %rcx
movq (%rbx,%rcx,8), %rdx
movl %r12d, %ecx
shlq %cl, %rdx
shrq $0x3f, %rdx
je 0xceff5
movq (%r14), %rcx
movq (%rcx,%r12,8), %rdx
testq %rdx, %rdx
je 0xceff5
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x17070
movq 0x10(%r14), %rax
incq %r12
cmpq %rax, %r12
jb 0xcefc1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x21657
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_search_arguments_new
static void *gt_tyr_search_arguments_new(void)
{
  Tyr_search_options *arguments
    = gt_malloc(sizeof (Tyr_search_options));
  arguments->str_inputindex = gt_str_new();
  arguments->strandspec = gt_str_new();
  arguments->queryfilenames = gt_str_array_new();
  arguments->showmodespec = gt_str_array_new();
  arguments->showmode = 0;
  arguments->strand = 0;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x28d7ad(%rip), %rsi    # 0x35c7c3
movl $0x30, %edi
movl $0x326, %edx            # imm = 0x326
callq 0x104226
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11be10
movq %rax, 0x8(%rbx)
callq 0x11be10
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_tallymer.c
// Function: gt_tyr_search_arguments_delete
static void gt_tyr_search_arguments_delete(void *tool_arguments)
{
  Tyr_search_options *arguments = tool_arguments;

  if (!arguments)
  {
    return;
  }
  gt_str_delete(arguments->str_inputindex);
  gt_str_delete(arguments->strandspec);
  gt_str_array_delete(arguments->queryfilenames);
  gt_str_array_delete(arguments->showmodespec);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xcf099
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11c144
movq 0x18(%rbx), %rdi
callq 0x11c144
leaq 0x28d738(%rip), %rsi    # 0x35c7c3
movq %rbx, %rdi
movl $0x33c, %edx            # imm = 0x33C
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tallymer.c
// Function: gt_tyr_search_arguments_check
static int gt_tyr_search_arguments_check(int rest_argc,
                                         void *tool_arguments,
                                         GtError *err)
{
  Optionargmodedesc showmodedesctable[] =
  {
    {"qseqnum","query sequence number",SHOWQSEQNUM},
    {"qpos","query position",SHOWQPOS},
    {"counts","number of occurrence counts",SHOWCOUNTS},
    {"sequence","mer-sequence",SHOWSEQUENCE}
  };

  Optionargmodedesc stranddesctable[] =
  {
    {"f","forward strand",STRAND_FORWARD},
    {"p","reverse strand",STRAND_REVERSE},
    {"fp","forward and reverse strand",STRAND_FORWARD | STRAND_REVERSE}
  };
  GtUword idx;
  Tyr_search_options *arguments = tool_arguments;

  if (rest_argc != 0)
  {
    gt_error_set(err,"superfluous arguments");
    return -1;
  }
  for (idx=0; idx<gt_str_array_size(arguments->showmodespec); idx++)
  {
    if (gt_optionargaddbitmask(showmodedesctable,
                         sizeof (showmodedesctable)/
                         sizeof (showmodedesctable[0]),
                         &arguments->showmode,
                         "-output",
                         gt_str_array_get(arguments->showmodespec,idx),
                         err) != 0)
    {
      return -1;
    }
  }
  if (gt_optionargaddbitmask(stranddesctable,
                          sizeof (stranddesctable)/
                          sizeof (stranddesctable[0]),
                          &arguments->strand,
                          "-output",
                          gt_str_get(arguments->strandspec),err) != 0)
  {
    return -1;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %eax
leaq 0x3e4504(%rip), %rsi    # 0x4b36e0
leaq 0x50(%rsp), %rdi
movl $0xc, %ecx
rep  movsq (%rsi), %es:(%rdi)
leaq 0x3e4550(%rip), %rsi    # 0x4b3740
movq %rsp, %rdi
movl $0x9, %ecx
rep  movsq (%rsi), %es:(%rdi)
testl %eax, %eax
je 0xcf21a
leaq 0x280d8b(%rip), %rsi    # 0x34ff91
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xcf2a7
movq 0x18(%r14), %rdi
callq 0x11c131
testq %rax, %rax
je 0xcf275
leaq 0x24(%r14), %r15
xorl %r12d, %r12d
leaq 0x281abe(%rip), %r13    # 0x350cf4
leaq 0x50(%rsp), %rbp
movq 0x18(%r14), %rdi
movq %r12, %rsi
callq 0x11bfb3
movl $0x4, %esi
movq %rbp, %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
movq %rbx, %r9
callq 0x1b7e64
testl %eax, %eax
jne 0xcf210
incq %r12
movq 0x18(%r14), %rdi
callq 0x11c131
cmpq %rax, %r12
jb 0xcf23b
movq 0x10(%r14), %rdi
addq $0x20, %r14
callq 0x11b0a1
leaq 0x281a6b(%rip), %rcx    # 0x350cf4
movq %rsp, %rdi
movl $0x3, %esi
movq %r14, %rdx
movq %rax, %r8
movq %rbx, %r9
callq 0x1b7e64
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
addq $0xb8, %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_tallymer.c
// Function: gt_tyr_search_runner
static int gt_tyr_search_runner(GT_UNUSED int argc,
                                GT_UNUSED const char **argv,
                                GT_UNUSED int parsed_args,
                                void *tool_arguments,
                                GtError *err)
{
  Tyr_search_options *arguments = tool_arguments;

  if (gt_tyrsearch(gt_str_get(arguments->str_inputindex),
                   arguments->queryfilenames,
                   arguments->showmode,
                   arguments->strand,
                   arguments->verbose,
                   arguments->performtest,
                   err) != 0)
  {
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq (%rcx), %rdi
callq 0x11b0a1
movq 0x8(%r14), %rsi
movl 0x24(%r14), %edx
movl 0x20(%r14), %ecx
movzbl 0x28(%r14), %r8d
movzbl 0x29(%r14), %r9d
movq %rbx, (%rsp)
movq %rax, %rdi
callq 0x202bf0
xorl %ecx, %ecx
negl %eax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_template.c
// Function: gt_template_option_parser_new
static GtOptionParser* gt_template_option_parser_new(void *tool_arguments)
{
  TemplateArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [file]", /* XXX */
                            "DESCRIBE YOUR TOOL IN ONE LINE HERE."); /* XXX */

  /* -bool */
  option = gt_option_new_bool("bool", "bool option template",
                              &arguments->bool_option_template, false);
  gt_option_parser_add_option(op, option);

  /* -str */
  option = gt_option_new_string("str", "str option template",
                                arguments->str_option_template, NULL);
  gt_option_parser_add_option(op, option);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xcf3f1
movq %rdi, %r14
leaq 0x27b311(%rip), %rdi    # 0x34a6a1
leaq 0x28e13e(%rip), %rsi    # 0x35d4d5
callq 0x107bfe
movq %rax, %rbx
leaq 0x2f6f58(%rip), %rdi    # 0x3c62fe
leaq 0x28e14d(%rip), %rsi    # 0x35d4fa
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x8(%r14), %rdx
leaq 0x2a2947(%rip), %rdi    # 0x371d14
leaq 0x28e13b(%rip), %rsi    # 0x35d50f
xorl %ecx, %ecx
callq 0x10a770
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x21690
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_template.c
// Function: gt_template_arguments_check
static int gt_template_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  TemplateArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  /* XXX: do some checking after the option have been parsed (usally this is not
     necessary and this function can be removed completely). */
  if (gt_str_length(arguments->str_option_template))
    printf("%s\n", gt_str_get(arguments->str_option_template));

  return had_err;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0xcf40b
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xcf438
testq %rbx, %rbx
je 0xcf433
movq 0x8(%rbx), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0xcf42f
movq 0x8(%rbx), %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0x17bd0
xorl %eax, %eax
popq %rbx
retq
callq 0x216fe
callq 0x216c7
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_template.c
// Function: gt_template_runner
static int gt_template_runner(int argc, const char **argv, int parsed_args,
                              void *tool_arguments, GT_UNUSED GtError *err)
{
  TemplateArguments *arguments = tool_arguments;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  /* XXX */
  if (arguments->bool_option_template)
    printf("argc=%d, parsed_args=%d\n", argc, parsed_args);
  printf("argv[0]=%s\n", argv[0]);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movl %edi, %r14d
testq %r8, %r8
je 0xcf460
movq %r8, %rdi
callq 0xfcc32
testb %al, %al
jne 0xcf4a1
testq %r15, %r15
je 0xcf49c
cmpb $0x1, (%r15)
jne 0xcf47e
leaq 0x28e0e0(%rip), %rdi    # 0x35d552
movl %r14d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x17070
movq (%rbx), %rsi
leaq 0x28e0e3(%rip), %rdi    # 0x35d56b
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2176c
callq 0x21735
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tir.c
// Function: gt_tir_arguments_new
static void* gt_tir_arguments_new(void)
{
  GtTirArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->str_indexname = gt_str_new();
  arguments->str_overlaps = gt_str_new();
  arguments->refseq_file = gt_str_new();
  arguments->cutoffs = gt_str_new();
  arguments->hmm_files = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x28e0b8(%rip), %rdx    # 0x35d590
movl $0x1, %edi
movl $0xb0, %esi
movl $0x40, %ecx
callq 0x10436a
movq %rax, %rbx
callq 0x11ac6c
movq %rax, (%rbx)
callq 0x11ac6c
movq %rax, 0x10(%rbx)
callq 0x11ac6c
movq %rax, 0x18(%rbx)
callq 0x11ac6c
movq %rax, 0x8(%rbx)
callq 0x11be10
movq %rax, 0xa0(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tir.c
// Function: gt_tir_arguments_delete
static void gt_tir_arguments_delete(void *tool_arguments)
{
  GtTirArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->str_indexname);
  gt_str_delete(arguments->cutoffs);
  gt_str_delete(arguments->refseq_file);
  gt_str_delete(arguments->str_overlaps);
  gt_str_array_delete(arguments->hmm_files);
  gt_option_delete(arguments->optionoverlaps);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xcf57c
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x11bdbf
movq 0x8(%rbx), %rdi
callq 0x11bdbf
movq 0x18(%rbx), %rdi
callq 0x11bdbf
movq 0x10(%rbx), %rdi
callq 0x11bdbf
movq 0xa0(%rbx), %rdi
callq 0x11c144
movq 0x98(%rbx), %rdi
callq 0x10a16a
leaq 0x28e022(%rip), %rsi    # 0x35d590
movq %rbx, %rdi
movl $0x53, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_tir.c
// Function: gt_tir_arguments_check
static int gt_tir_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  GtTirArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (!had_err) {
    if (gt_option_is_set(arguments->optionoverlaps)) {
      if (strcmp(gt_str_get(arguments->str_overlaps), "no") == 0) {
        arguments->best_overlaps = false;
        arguments->no_overlaps = true;
        arguments->longest_overlaps = false;
      } else if (strcmp(gt_str_get(arguments->str_overlaps), "best") == 0 ) {
        arguments->best_overlaps = true;
        arguments->no_overlaps = false;
        arguments->longest_overlaps = false;
      } else if (strcmp(gt_str_get(arguments->str_overlaps), "longest") == 0 ) {
        arguments->best_overlaps = false;
        arguments->no_overlaps = false;
        arguments->longest_overlaps = true;
      } else if (strcmp(gt_str_get(arguments->str_overlaps), "all") == 0 ) {
        arguments->best_overlaps = false;
        arguments->no_overlaps = false;
        arguments->longest_overlaps = false;
      } else {
        gt_assert(0); /* cannot happen */
      }
    } else {
      /* default is "best" */
      arguments->longest_overlaps = false;
      arguments->best_overlaps = true;  /* take best prediction
                                           if overlap occurs, default */
      arguments->no_overlaps = false; /* overlapping predictions (not)
                                         allowed*/
    }
  }

  return had_err;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0xcfa59
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xcfb37
testq %rbx, %rbx
je 0xcfb32
movq 0x98(%rbx), %rdi
callq 0x10ac3f
testb %al, %al
je 0xcfaef
movq 0x10(%rbx), %rdi
callq 0x11b0a1
cmpb $0x6e, (%rax)
jne 0xcfa90
cmpb $0x6f, 0x1(%rax)
jne 0xcfa90
cmpb $0x0, 0x2(%rax)
je 0xcfb1e
movq 0x10(%rbx), %rdi
callq 0x11b0a1
leaq 0x2ef8a8(%rip), %rsi    # 0x3bf348
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xcfb01
movq 0x10(%rbx), %rdi
callq 0x11b0a1
leaq 0x281889(%rip), %rsi    # 0x351345
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
je 0xcfb0c
movq 0x10(%rbx), %rdi
callq 0x11b0a1
leaq 0x2ef85e(%rip), %rsi    # 0x3bf336
movq %rax, %rdi
callq 0x17a40
testl %eax, %eax
jne 0xcfb3c
movw $0x0, 0x88(%rbx)
jmp 0xcfb27
movb $0x0, 0x8a(%rbx)
movw $0x1, 0x88(%rbx)
jmp 0xcfb2e
movw $0x1, 0x88(%rbx)
jmp 0xcfb27
movw $0x0, 0x88(%rbx)
movb $0x1, 0x8a(%rbx)
jmp 0xcfb2e
movw $0x100, 0x88(%rbx)      # imm = 0x100
movb $0x0, 0x8a(%rbx)
xorl %eax, %eax
popq %rbx
retq
callq 0x2184c
callq 0x217da
callq 0x21813
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_trieins.c
// Function: gt_trieins
int gt_trieins(int argc, const char **argv, GtError *err)
{
  bool haserr = false;
  int parsed_args;
  bool onlyins = false;

  gt_error_check(err);

  switch (parse_options(&onlyins,&parsed_args, argc, argv, err)) {
    case GT_OPTION_PARSER_OK: break;
    case GT_OPTION_PARSER_ERROR: return -1;
    case GT_OPTION_PARSER_REQUESTS_EXIT: return 0;
  }
  gt_assert(parsed_args == 1);

  if (gt_test_trieins(onlyins,argv[parsed_args],err) != 0)
  {
    haserr = true;
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
movb $0x0, 0xb(%rsp)
testq %rdx, %rdx
je 0xcff52
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xcffa7
leaq 0xb(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
jmp 0xcff64
leaq 0xb(%rsp), %rdi
leaq 0xc(%rsp), %rsi
movl %ebp, %edx
movq %r14, %rcx
xorl %r8d, %r8d
callq 0xcffb1
cmpl $0x1, %eax
je 0xcff77
cmpl $0x2, %eax
jne 0xcff7e
xorl %eax, %eax
jmp 0xcff9e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xcff9e
cmpl $0x1, 0xc(%rsp)
jne 0xcffac
movzbl 0xb(%rsp), %edi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x200a1c
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x21930
callq 0x21967
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_trieins.c
// Function: parse_options
static GtOPrval parse_options(bool *onlyins,int *parsed_args,
                              int argc, const char **argv, GtError *err)
{
  GtOptionParser *op;
  GtOption *option;
  GtOPrval oprval;

  gt_error_check(err);
  op = gt_option_parser_new("[options] indexname",
                         "Perform trie insertions and check consistency.");
  gt_option_parser_set_mail_address(op, "<kurtz@zbh.uni-hamburg.de>");
  option= gt_option_new_bool("ins","perform only insertions",onlyins,false);
  gt_option_parser_add_option(op, option);
  gt_option_parser_set_min_max_args(op, 1U, 1U);
  oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
                                  err);
  gt_option_parser_delete(op);
  return oprval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r13
testq %r8, %r8
je 0xcffdf
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xd006e
leaq 0x28dc8e(%rip), %rdi    # 0x35dc74
leaq 0x28dc9b(%rip), %rsi    # 0x35dc88
callq 0x107bfe
movq %rax, %r12
leaq 0x2762d0(%rip), %rsi    # 0x3462cc
movq %rax, %rdi
callq 0x107e5c
leaq 0x2ceb9b(%rip), %rdi    # 0x39eba6
leaq 0x28dca5(%rip), %rsi    # 0x35dcb7
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %r12, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r12, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x10874b
leaq 0x4f5cc(%rip), %r8      # 0x11f60c
movq %r12, %rdi
movq %r15, %rsi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0x10875d
movl %eax, %ebx
movq %r12, %rdi
callq 0x10a0b4
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2199e
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_uniq.c
// Function: gt_uniq_arguments_delete
static void gt_uniq_arguments_delete(void *tool_arguments)
{
  UniqArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0xd00f4
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xff22c
movq 0x8(%rbx), %rdi
callq 0x10b00c
leaq 0x28dbe9(%rip), %rsi    # 0x35dccf
movq %rbx, %rdi
movl $0x31, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_uniq.c
// Function: gt_uniq_option_parser_new
static GtOptionParser* gt_uniq_option_parser_new(void *tool_arguments)
{
  UniqArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file]", "Filter out repeated "
                            "feature node graphs in a sorted GFF3 file.");

  /* -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);

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_max_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd0166
movq %rdi, %r14
leaq 0x275f87(%rip), %rdi    # 0x34608f
leaq 0x28dbee(%rip), %rsi    # 0x35dcfd
callq 0x107bfe
movq %rax, %rbx
movq %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 0x7c780(%rip), %rsi     # 0x14c8c4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x107d3d
movq %rbx, %rdi
movl $0x1, %esi
callq 0x10873c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x219d5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_uniq.c
// Function: gt_uniq_runner
static int gt_uniq_runner(GT_UNUSED int argc, const char **argv,
                          int parsed_args, void *tool_arguments, GtError *err)
{
  UniqArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream,
               *uniq_stream = NULL,
               *gff3_out_stream = NULL;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create gff3 input stream */
  gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args]);
  if (arguments->verbose && arguments->outfp)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);

  /* create uniq stream */
  uniq_stream = gt_uniq_stream_new(gff3_in_stream);

  /* create gff3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(uniq_stream, arguments->outfp);

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

  /* free */
  gt_node_stream_delete(gff3_out_stream);
  gt_node_stream_delete(uniq_stream);
  gt_node_stream_delete(gff3_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
testq %r8, %r8
je 0xd018f
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xd0207
testq %r14, %r14
je 0xd0202
movslq %ebp, %rax
movq (%r15,%rax,8), %rdi
callq 0x145d7c
movq %rax, %r15
cmpb $0x1, (%r14)
jne 0xd01b8
cmpq $0x0, 0x10(%r14)
je 0xd01b8
movq %r15, %rdi
callq 0x145b36
movq %r15, %rdi
callq 0x18408f
movq %rax, %r12
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x146fc0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162f5d
movl %eax, %ebx
movq %r14, %rdi
callq 0x162dee
movq %r12, %rdi
callq 0x162dee
movq %r15, %rdi
callq 0x162dee
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x21a43
callq 0x21a0c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_wtree.c
// Function: gt_wtree_option_parser_new
static GtOptionParser* gt_wtree_option_parser_new(void *tool_arguments)
{
  GtToolbox *wtree_toolbox = tool_arguments;
  GtOptionParser *op;
  gt_assert(wtree_toolbox);
  op = gt_option_parser_new("[option ...] tool [argument ...]",
                            "Call an wtree manipulation tool "
                            "and pass argument(s) to it.");
  gt_option_parser_set_comment_func(op, gt_toolbox_show, wtree_toolbox);
  gt_option_parser_set_min_args(op, 1U);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd02aa
movq %rdi, %rbx
leaq 0x276881(%rip), %rdi    # 0x346af2
leaq 0x28db11(%rip), %rsi    # 0x35dd89
callq 0x107bfe
movq %rax, %r14
leaq 0x4db17(%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 0x21a7a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_wtree.c
// Function: gt_wtree_runner
static int gt_wtree_runner(int argc, const char **argv, int parsed_args,
                              void *tool_arguments, GT_UNUSED GtError *err)
{
  GtToolbox *wtree_toolbox = tool_arguments;
  GtTool *tool = NULL;
  int had_err = 0;
  char **nargv = NULL;

  gt_error_check(err);
  gt_assert(wtree_toolbox);

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

  /* call wtree 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 0xd02dd
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xd0374
testq %r15, %r15
je 0xd036f
movslq %r14d, %rax
leaq (%r12,%rax,8), %r13
movq (%r13), %rsi
movq %r15, %rdi
callq 0x11dce1
testq %rax, %rax
je 0xd0339
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 0xd0356
movq (%r13), %rdx
leaq 0x28da91(%rip), %rsi    # 0x35ddd5
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 0x21ae8
callq 0x21ab1
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_wtree_bench.c
// Function: gt_wtree_bench_option_parser_new
static GtOptionParser* gt_wtree_bench_option_parser_new(void *tool_arguments)
{
  GtWaveletBenchArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] encoded_sequence",
                            "Testing and benchmarking for wtree.");

  /* -safe */
  option = gt_option_new_string("safe", "safe files to disk, currently not "
                                "implemented",
                                arguments->safe, NULL);
  gt_option_parser_add_option(op, option);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd0447
movq %rdi, %rbx
leaq 0x28da44(%rip), %rdi    # 0x35de4e
leaq 0x28da5b(%rip), %rsi    # 0x35de6c
callq 0x107bfe
movq %rax, %r14
movq (%rbx), %rdx
leaq 0x2f5cbb(%rip), %rdi    # 0x3c60de
leaq 0x28da66(%rip), %rsi    # 0x35de90
xorl %ecx, %ecx
callq 0x10a770
movq %r14, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x21b1f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_wtree_bench.c
// Function: gt_wtree_bench_arguments_check
static int gt_wtree_bench_arguments_check(int rest_argc,
                                          void *tool_arguments,
                                          GtError *err)
{
  GtWaveletBenchArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (rest_argc == 0) {
    gt_error_set(err, "no encseq basename given");
    had_err = 1;
  }
  else if (rest_argc > 1) {
    gt_error_set(err, "give only one encseq basename");
    had_err = 1;
  }
  if (!had_err && gt_str_length(arguments->safe))
    printf("%s\n", gt_str_get(arguments->safe));

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0xd0469
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0xd04c3
testq %r14, %r14
je 0xd04be
testl %ebp, %ebp
je 0xd0480
cmpl $0x2, %ebp
jl 0xd0498
leaq 0x28da78(%rip), %rsi    # 0x35def6
jmp 0xd0487
leaq 0x28da56(%rip), %rsi    # 0x35dedd
movq %rbx, %rdi
xorl %eax, %eax
callq 0xfcb67
movl $0x1, %ebx
jmp 0xd04b7
movq (%r14), %rdi
callq 0x11b0ca
xorl %ebx, %ebx
testq %rax, %rax
je 0xd04b7
movq (%r14), %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0x17bd0
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x21b8d
callq 0x21b56
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/array2dim.c
// Function: gt_array2dim_example
int gt_array2dim_example(GT_UNUSED GtError *err)
{
  double **a2dim;
  int i, j;
  gt_error_check(err);

  /* create a 10 x 20 double array */
  gt_array2dim_malloc(a2dim, 10, 20);

  /* ... (use array a2dim in conventional way via a2dim[row][column]) */
  for (i = 1; i < 10; i++) {
    for (j = 1; j < 20; j++)
      a2dim[i][j] = i + j;
  }

  /* free */
  gt_array2dim_delete(a2dim);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd39b6
callq 0xfcc32
testb %al, %al
jne 0xd3ada
leaq 0x28b668(%rip), %r14    # 0x35f025
movl $0x50, %edi
movq %r14, %rsi
movl $0x1d, %edx
callq 0x104226
movq %rax, %rbx
movl $0x640, %edi            # imm = 0x640
movq %r14, %rsi
movl $0x1d, %edx
callq 0x104226
movq %rax, (%rbx)
addq $0xa0, %rax
movl $0x1, %ecx
movq %rax, (%rbx,%rcx,8)
incq %rcx
addq $0xa0, %rax
cmpq $0xa, %rcx
jne 0xd39f2
movl $0x1, %eax
movl $0x3, %ecx
movdqa 0x285009(%rip), %xmm0   # 0x358a20
movdqa 0x285011(%rip), %xmm1   # 0x358a30
movdqa 0x28b5d9(%rip), %xmm2   # 0x35f000
pshufd $0xf5, %xmm2, %xmm3     # xmm3 = xmm2[1,1,3,3]
movq (%rbx,%rax,8), %rdx
movl %ecx, %esi
xorl %edi, %edi
movq %rdi, %xmm4
pshufd $0x44, %xmm4, %xmm4     # xmm4 = xmm4[0,1,0,1]
por %xmm0, %xmm4
pxor %xmm1, %xmm4
movdqa %xmm2, %xmm5
pcmpgtd %xmm4, %xmm5
pshufd $0xf5, %xmm4, %xmm4     # xmm4 = xmm4[1,1,3,3]
pcmpeqd %xmm3, %xmm4
pand %xmm5, %xmm4
movd %xmm4, %r8d
testb $0x1, %r8b
je 0xd3a78
leal -0x1(%rsi), %r8d
xorps %xmm5, %xmm5
cvtsi2sd %r8d, %xmm5
movsd %xmm5, 0x8(%rdx,%rdi,8)
pextrw $0x4, %xmm4, %r8d
testb $0x1, %r8b
je 0xd3a91
xorps %xmm4, %xmm4
cvtsi2sd %esi, %xmm4
movsd %xmm4, 0x10(%rdx,%rdi,8)
addq $0x2, %rdi
addl $0x2, %esi
cmpq $0x14, %rdi
jne 0xd3a34
incq %rax
incl %ecx
cmpq $0xa, %rax
jne 0xd3a2c
movq (%rbx), %rdi
leaq 0x28b572(%rip), %r14    # 0x35f025
movq %r14, %rsi
movl $0x26, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x26, %edx
callq 0x1045eb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x22fb8
nop