LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_idxlocali.c
// Function: gt_idxlocali_runner
static int gt_idxlocali_runner(GT_UNUSED int argc,
                               GT_UNUSED const char **argv,
                               GT_UNUSED int parsed_args,
                               void *tool_arguments,
                               GtError * err)
{
  IdxlocaliOptions *arguments = tool_arguments;
  bool haserr = false;
  GtUword idx;

  gt_error_check(err);
  gt_assert(arguments != NULL);

  gt_assert(parsed_args == argc);
  printf("# indexname(%s)=%s\n", arguments->withesa ? "esa" : "pck",
         gt_str_get(arguments->indexname));
  for (idx = 0; idx < gt_str_array_size (arguments->queryfiles); idx++)
  {
    printf("# queryfile=%s\n",gt_str_array_get (arguments->queryfiles, idx));
  }
  printf("# threshold="GT_WU"\n", arguments->threshold);
  if (!haserr && gt_runidxlocali (arguments, err) != 0)
  {
    haserr = true;
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %edi, %r15d
testq %r8, %r8
je 0x2f4bd
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2f5c1
testq %r14, %r14
je 0x2f565
cmpl %r15d, %ebp
jne 0x2f593
leaq 0x2ca727(%rip), %rax    # 0x2f9bfd
cmpb $0x0, 0x20(%r14)
leaq 0x2be2cc(%rip), %r15    # 0x2ed7ae
cmovneq %rax, %r15
movq 0x8(%r14), %rdi
callq 0xad1fa
leaq 0x2bfdea(%rip), %rdi    # 0x2ef2e0
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
leaq 0x2ba930(%rip), %r15    # 0x2e9e3a
xorl %r12d, %r12d
movq (%r14), %rdi
callq 0xae61c
cmpq %rax, %r12
jae 0x2f537
movq (%r14), %rdi
movq %r12, %rsi
callq 0xae386
movq %r15, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
incq %r12
jmp 0x2f50d
movq 0x28(%r14), %rsi
leaq 0x2bfdb2(%rip), %rdi    # 0x2ef2f4
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x17070
movq %r14, %rdi
movq %rbx, %rsi
callq 0x161bd0
negl %eax
sbbl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x4089fc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b5a9d(%rip), %rsi    # 0x2e5013
leaq 0x2b6cef(%rip), %rdx    # 0x2e626c
leaq 0x2bfd48(%rip), %rcx    # 0x2ef2cc
leaq 0x2bfbaf(%rip), %r8     # 0x2ef13a
movl $0x9d, %r9d
jmp 0x2f5ed
movq 0x4089ce(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b5a6f(%rip), %rsi    # 0x2e5013
leaq 0x2b7315(%rip), %rdx    # 0x2e68c0
leaq 0x2bfd1a(%rip), %rcx    # 0x2ef2cc
leaq 0x2bfb81(%rip), %r8     # 0x2ef13a
movl $0x9f, %r9d
jmp 0x2f5ed
movq 0x4089a0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b5a41(%rip), %rsi    # 0x2e5013
leaq 0x2b5be6(%rip), %rdx    # 0x2e51bf
leaq 0x2bfcec(%rip), %rcx    # 0x2ef2cc
leaq 0x2bfb53(%rip), %r8     # 0x2ef13a
movl $0x9c, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_inlineseq_add.c
// Function: gt_inlineseq_add_arguments_new
static void *gt_inlineseq_add_arguments_new(void)
{
  InlineseqAddArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->s2fi = gt_seqid2file_info_new();
  arguments->ofi = gt_output_file_info_new();
  arguments->outfp = NULL;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2bfcde(%rip), %rdx    # 0x2ef305
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x24
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x116724
movq %rax, (%rbx)
callq 0x9b6b4
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_inlineseq_add.c
// Function: gt_inlineseq_add_arguments_delete
static void gt_inlineseq_add_arguments_delete(void *tool_arguments)
{
  InlineseqAddArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_seqid2file_info_delete(arguments->s2fi);
  gt_output_file_info_delete(arguments->ofi);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x2f689
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x8da06
movq (%rbx), %rdi
callq 0x116765
movq 0x8(%rbx), %rdi
callq 0x9ba24
leaq 0x2bfc88(%rip), %rsi    # 0x2ef305
pushq $0x32
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_inlineseq_add.c
// Function: gt_inlineseq_add_option_parser_new
static GtOptionParser* gt_inlineseq_add_option_parser_new(void *tool_arguments)
{
  GtOptionParser *op;
  GT_UNUSED GtOption *option;
  InlineseqAddArguments *arguments = tool_arguments;

  /* init */
  op = gt_option_parser_new("[options] [GFF3_file ...]",
                            "Adds inline sequences from external source to "
                            "GFF3 input.");

  gt_seqid2file_register_options(op, arguments->s2fi);
  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2bfc8a(%rip), %rdi    # 0x2ef322
leaq 0x2bfc9d(%rip), %rsi    # 0x2ef33c
callq 0x97df5
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x116b0e
movq 0x8(%rbx), %rdi
addq $0x10, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_inlineseq_split.c
// Function: gt_inlineseq_split_arguments_new
static void* gt_inlineseq_split_arguments_new(void)
{
  GtInlineseqSplitArguments *arguments
    = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->seqoutfile = gt_str_new();
  arguments->gffoutfile = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2bfb4e(%rip), %rdx    # 0x2ef39d
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
pushq $0x26
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_inlineseq_split.c
// Function: gt_inlineseq_split_arguments_delete
static void gt_inlineseq_split_arguments_delete(void *tool_arguments)
{
  GtInlineseqSplitArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_delete(arguments->seqoutfile);
    gt_str_delete(arguments->gffoutfile);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x2f8a3
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
leaq 0x2bfb06(%rip), %rsi    # 0x2ef39d
pushq $0x32
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_inlineseq_split.c
// Function: gt_inlineseq_split_option_parser_new
static GtOptionParser* gt_inlineseq_split_option_parser_new(
                                                   void *tool_arguments)
{
  GtInlineseqSplitArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption GT_UNUSED *option, *seqopt, *gff3opt;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("(-seqfile <seqfile> | -gff3file <gff3file>) "
                            "[GFF3_file]",
                            "Split GFF3 annotations with inline sequences into "
                            "separate files.");

  /* -seqfile */
  seqopt = gt_option_new_string("seqfile", "output file for sequences as FASTA",
                                arguments->seqoutfile, NULL);
  gt_option_parser_add_option(op, seqopt);

  /* -gff3file */
  gff3opt = gt_option_new_string("gff3file", "output file for annotations "
                                             "as GFF3",
                                 arguments->gffoutfile, NULL);
  gt_option_parser_add_option(op, gff3opt);

  gt_option_is_mandatory_either(seqopt, gff3opt);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2f928
movq %rdi, %r14
leaq 0x2bfb29(%rip), %rdi    # 0x2ef3e1
leaq 0x2bfb5a(%rip), %rsi    # 0x2ef419
callq 0x97df5
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x30e829(%rip), %rdi    # 0x33e0fa
leaq 0x2bfb83(%rip), %rsi    # 0x2ef45b
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x8(%r14), %rdx
leaq 0x2eded1(%rip), %rdi    # 0x31d7c9
leaq 0x2bfb7f(%rip), %rsi    # 0x2ef47e
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r15, %rdi
movq %r14, %rsi
callq 0x9ae7a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x408639(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b56da(%rip), %rsi    # 0x2e5013
leaq 0x318d13(%rip), %rdx    # 0x348653
leaq 0x2bfa75(%rip), %rcx    # 0x2ef3bc
leaq 0x2bfa4f(%rip), %r8     # 0x2ef39d
pushq $0x3c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_interfeat.c
// Function: gt_interfeat_arguments_new
static void* gt_interfeat_arguments_new(void)
{
  InterFeatArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->outside_type = gt_str_new();
  arguments->inter_type = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2bf93e(%rip), %rdx    # 0x2ef4c9
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x22
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0x9b6b4
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_interfeat.c
// Function: gt_interfeat_arguments_delete
static void gt_interfeat_arguments_delete(void *tool_arguments)
{
  InterFeatArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->inter_type);
  gt_str_delete(arguments->outside_type);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x2fbfa
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
movq 0x8(%rbx), %rdi
callq 0xae103
movq (%rbx), %rdi
callq 0xae103
leaq 0x2bf8db(%rip), %rsi    # 0x2ef4c9
pushq $0x31
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_interfeat.c
// Function: gt_interfeat_option_parser_new
static GtOptionParser* gt_interfeat_option_parser_new(void *tool_arguments)
{
  InterFeatArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;

  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Add intermediary "
                            "features between outside features in given "
                            "GFF3 file(s).");

  /* -outside */
  option = gt_option_new_string("outside", "set outside type",
                                arguments->outside_type, gt_ft_exon);
  gt_option_parser_add_option(op, option);

  /* -inter */
  option = gt_option_new_string("inter", "set intermediary type",
                                arguments->inter_type, gt_ft_intron);
  gt_option_parser_add_option(op, option);

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

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2fc90
movq %rdi, %rbx
leaq 0x2ba8e7(%rip), %rdi    # 0x2ea4f9
leaq 0x2bf8c9(%rip), %rsi    # 0x2ef4e2
callq 0x97df5
movq %rax, %r14
movq (%rbx), %rdx
leaq 0x3319f3(%rip), %rdi    # 0x36161e
leaq 0x2bf8fa(%rip), %rsi    # 0x2ef52c
leaq 0x304ecd(%rip), %rcx    # 0x334b06
callq 0x9ad12
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x8(%rbx), %rdx
leaq 0x347aae(%rip), %rdi    # 0x377702
leaq 0x2bf8e2(%rip), %rsi    # 0x2ef53d
leaq 0x3049b2(%rip), %rcx    # 0x334614
callq 0x9ad12
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x4082d1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b5372(%rip), %rsi    # 0x2e5013
leaq 0x3189ab(%rip), %rdx    # 0x348653
leaq 0x2ba82b(%rip), %rcx    # 0x2ea4da
leaq 0x2bf813(%rip), %r8     # 0x2ef4c9
pushq $0x3a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_interfeat.c
// Function: gt_interfeat_runner
static int gt_interfeat_runner(int argc, const char **argv, int parsed_args,
                          void *tool_arguments, GtError *err)
{
  InterFeatArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream,
               *inter_feature_stream,
               *gff3_out_stream;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create a gff3 input stream */
  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
                                                  argv + parsed_args);

  /* create intermediary feature stream */
  inter_feature_stream =
    gt_inter_feature_stream_new(gff3_in_stream,
                                gt_str_get(arguments->outside_type),
                                gt_str_get(arguments->inter_type));

  /* create gff3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(inter_feature_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(inter_feature_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, %r12d
movq %rsi, %r15
movl %edi, %ebp
testq %r8, %r8
je 0x2fcf1
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2fd98
testq %r14, %r14
je 0x2fd6e
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r15,%rax,8), %rsi
movl %ebp, %edi
callq 0xdeebd
movq %rax, %r15
movq (%r14), %rdi
callq 0xad1fa
movq %rax, %r12
movq 0x8(%r14), %rdi
callq 0xad1fa
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xf2f98
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0xe07df
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102b93
movl %eax, %ebx
movq %r14, %rdi
callq 0x10297b
movq %r12, %rdi
callq 0x10297b
movq %r15, %rdi
callq 0x10297b
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x4081f3(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b5294(%rip), %rsi    # 0x2e5013
leaq 0x3188cd(%rip), %rdx    # 0x348653
leaq 0x2ba7e4(%rip), %rcx    # 0x2ea571
leaq 0x2bf735(%rip), %r8     # 0x2ef4c9
pushq $0x5b
jmp 0x2fdc0
movq 0x4081c9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b526a(%rip), %rsi    # 0x2e5013
leaq 0x2b540f(%rip), %rdx    # 0x2e51bf
leaq 0x2ba7ba(%rip), %rcx    # 0x2ea571
leaq 0x2bf70b(%rip), %r8     # 0x2ef4c9
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_kmer_database.c
// Function: gt_kmer_database_arguments_check
static int gt_kmer_database_arguments_check(int rest_argc,
                                            void *tool_arguments,
                                            GtError *err)
{
  GtKmerDatabaseArguments *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");
    had_err = -1;
  }

  if (!had_err && gt_str_length(arguments->print_filename) > 0UL) {
    if (!arguments->verbose) {
      gt_error_set(err, "-outfile needs -verbose option");
      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 0x300e7
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x3015b
testq %r14, %r14
je 0x3012d
cmpl $0x1, %ebp
jne 0x30114
movq 0x20(%r14), %rdi
callq 0xad289
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x30128
cmpb $0x0, 0x18(%r14)
jne 0x30128
leaq 0x2bf837(%rip), %rsi    # 0x2ef949
jmp 0x3011b
leaq 0x2bf80f(%rip), %rsi    # 0x2ef92a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x407e34(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b4ed5(%rip), %rsi    # 0x2e5013
leaq 0x31850e(%rip), %rdx    # 0x348653
leaq 0x2bf7bd(%rip), %rcx    # 0x2ef909
leaq 0x2bf41d(%rip), %r8     # 0x2ef570
movl $0xad, %r9d
jmp 0x30187
movq 0x407e06(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b4ea7(%rip), %rsi    # 0x2e5013
leaq 0x2b504c(%rip), %rdx    # 0x2e51bf
leaq 0x2bf78f(%rip), %rcx    # 0x2ef909
leaq 0x2bf3ef(%rip), %r8     # 0x2ef570
movl $0xac, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: gt_linspace_align_arguments_new
static void* gt_linspace_align_arguments_new(void)
{
  GtLinspaceArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->outputfile = gt_str_new();
  arguments->strings = gt_str_array_new();
  arguments->files = gt_str_array_new();
  arguments->linearcosts = gt_str_array_new();
  arguments->affinecosts = gt_str_array_new();
  arguments->diagonalbonds = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2bf080(%rip), %rdx    # 0x2efa68
pushq $0x1
popq %rdi
pushq $0x50
popq %rsi
pushq $0x54
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xae154
movq %rax, 0x8(%rbx)
callq 0xae154
movq %rax, 0x10(%rbx)
callq 0xae154
movq %rax, 0x18(%rbx)
callq 0xae154
movq %rax, 0x20(%rbx)
callq 0xae154
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: gt_linspace_align_arguments_delete
static void gt_linspace_align_arguments_delete(void *tool_arguments)
{
  GtLinspaceArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_delete(arguments->outputfile);
    gt_str_array_delete(arguments->strings);
    gt_str_array_delete(arguments->files);
    gt_str_array_delete(arguments->linearcosts);
    gt_str_array_delete(arguments->affinecosts);
    gt_str_array_delete(arguments->diagonalbonds);
    gt_free(arguments);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x30a84
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae662
movq 0x10(%rbx), %rdi
callq 0xae662
movq 0x18(%rbx), %rdi
callq 0xae662
movq 0x20(%rbx), %rdi
callq 0xae662
movq 0x28(%rbx), %rdi
callq 0xae662
leaq 0x2beff0(%rip), %rsi    # 0x2efa68
pushq $0x68
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: get_fastasequences
static int get_fastasequences(GtSequenceTable *sequence_table,
                              const GtStr *filename,
                              GtError *err)
{
  int had_err = 0;
  GtFastaReader *reader;

  gt_assert(sequence_table != NULL);
  reader = gt_fasta_reader_rec_new (filename);
  had_err = gt_fasta_reader_run(reader, NULL, save_fastasequence,
                                NULL, sequence_table, err);
  gt_fasta_reader_delete(reader);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x31d82
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x8cb01
movq %rax, %r15
leaq 0x1c7(%rip), %rdx       # 0x31f25
movq %rax, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x8c53c
movl %eax, %ebx
movq %r15, %rdi
callq 0x8c4d2
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x4061df(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b3280(%rip), %rsi    # 0x2e5013
leaq 0x2be4e9(%rip), %rdx    # 0x2f0283
leaq 0x2be4f9(%rip), %rcx    # 0x2f029a
leaq 0x2bdcc0(%rip), %r8     # 0x2efa68
movl $0x1dd, %r9d            # imm = 0x1DD
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: gt_encode_sequence_table
static void gt_encode_sequence_table(const GtAlphabet *alphabet,
                                     GtSequenceTable *sequence_table)
{
  GtUword idx;

  for (idx = 0; idx < sequence_table->size; idx++)
  {
    GtStr *gt_str = sequence_table->seqarray[idx];
    GtUchar *seq = (GtUchar*) gt_str_get(gt_str);

    gt_alphabet_encode_seq(alphabet, seq,(const char*) seq,
                           gt_str_length(gt_str));
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
cmpq 0x8(%rbx), %r13
jae 0x31e02
movq (%rbx), %rax
movq (%rax,%r13,8), %r15
movq %r15, %rdi
callq 0xad1fa
movq %rax, %r12
movq %r15, %rdi
callq 0xad289
movq %r14, %rdi
movq %r12, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x57621
incq %r13
jmp 0x31dcc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: gt_sequence_table_delete
static void gt_sequence_table_delete(GtSequenceTable *sequence_table)
{
  GtUword i;
  if (sequence_table != NULL)
  {
    for (i = 0; i < sequence_table->size ; i++)
    {
      gt_str_delete(sequence_table->seqarray[i]);
    }
    gt_free(sequence_table->seqarray);
    gt_free(sequence_table);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x31edf
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r14
jae 0x31eb4
movq (%rdi,%r14,8), %rdi
callq 0xae103
incq %r14
jmp 0x31e9d
leaq 0x2bdbad(%rip), %r14    # 0x2efa68
movq %r14, %rsi
movl $0x80, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x81, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: gt_sequence_table_new
static GtSequenceTable* gt_sequence_table_new()
{
  GtSequenceTable *sequence_table;

  sequence_table = gt_malloc(sizeof(*sequence_table));
  sequence_table->seqarray = gt_malloc(sizeof(*sequence_table->seqarray));
  sequence_table->size = 0;
  sequence_table->maxsize = 1;
  return sequence_table;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x2bdb7d(%rip), %rbx    # 0x2efa68
pushq $0x18
popq %rdi
pushq $0x70
popq %rdx
movq %rbx, %rsi
callq 0x93160
movq %rax, %r14
pushq $0x8
popq %rdi
pushq $0x71
popq %rdx
movq %rbx, %rsi
callq 0x93160
movq %rax, (%r14)
andq $0x0, 0x8(%r14)
movq $0x1, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: save_fastasequence
static int save_fastasequence(const char *seqpart, GT_UNUSED GtUword length,
                              void *data, GT_UNUSED GtError* err)
{
  GtSequenceTable *fasta_seqs = (GtSequenceTable*) data;

  if (fasta_seqs->maxsize == fasta_seqs->size)
  {
    fasta_seqs->maxsize += 10;
    fasta_seqs->seqarray = gt_realloc(fasta_seqs->seqarray,
                                      fasta_seqs->maxsize*
                                      sizeof (*fasta_seqs->seqarray));
  }
  fasta_seqs->seqarray[fasta_seqs->size++] = gt_str_new_cstr(seqpart);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x10(%rdx), %rax
cmpq 0x8(%rdx), %rax
jne 0x31f60
leaq 0xa(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq (%rbx), %rdi
leaq 0x50(,%rax,8), %rsi
leaq 0x2bdb15(%rip), %rdx    # 0x2efa68
movl $0x1cf, %ecx            # imm = 0x1CF
callq 0x93472
movq %rax, (%rbx)
movq %r14, %rdi
callq 0xacbd1
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rbx)
movq %rax, (%rcx,%rdx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: gt_linspace_print_sequence
static void gt_linspace_print_sequence(const GtUchar *characters,
                                       GtUchar wildcardshow,
                                       const GtUchar *seq, GtUword len,
                                       FILE *fp)
{
  const GtUword linewidth = 80;
  GtUword idx;

  fprintf(fp, "######\n");
  for (idx = 0; idx < len; idx++)
  {
    GtUchar cc;
    if (characters == NULL)
    {
      cc = seq[idx];
    } else
    {
      if (GT_ISSPECIAL(seq[idx]))
      {
        cc = wildcardshow;
      } else
      {
        cc = characters[seq[idx]];
      }
    }
    fputc(cc,fp);
    if ((idx + 1) % linewidth == 0)
    {
      fputc('\n',fp);
    }
  }
  if (idx % linewidth != 0)
  {
    fputc('\n',fp);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq %rdi, %r12
leaq 0x34f8cf(%rip), %rdi    # 0x3819bc
pushq $0x7
popq %rsi
pushq $0x1
popq %r13
movq %r13, %rdx
movq %r8, %rcx
callq 0x17f00
xorl %ebp, %ebp
movq %r13, %rax
xorl %edx, %edx
pushq $0x50
popq %rcx
divq %rcx
cmpq %rbp, %r14
je 0x3215c
movq 0x10(%rsp), %rcx
movb (%rcx,%rbp), %dl
testq %r12, %r12
je 0x32130
movl 0xc(%rsp), %ecx
cmpb $-0x3, %dl
ja 0x32132
movzbl %dl, %ecx
movb (%r12,%rcx), %cl
jmp 0x32132
movl %edx, %ecx
imulq $0x50, %rax, %r15
decq %r15
movzbl %cl, %edi
movq %rbx, %rsi
callq 0x17930
cmpq %rbp, %r15
jne 0x32154
pushq $0xa
popq %rdi
movq %rbx, %rsi
callq 0x17930
incq %r13
incq %rbp
jmp 0x32101
movq %r14, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x32182
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17930
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_loccheck.c
// Function: gt_loccheck_runner
static int gt_loccheck_runner(int argc, const char **argv, int parsed_args,
                              GT_UNUSED void *tool_arguments, GtError *err)
{
  GtNodeStream *gff3_in_stream = NULL, *checker_stream = NULL;
  int had_err = 0;
  gt_error_check(err);

  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
                                                  argv + parsed_args);

  checker_stream = gt_visitor_stream_new(gff3_in_stream,
                                         gt_check_boundaries_visitor_new());
  gt_assert(checker_stream);

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

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

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, %r15d
movq %rsi, %r14
movl %edi, %ebp
testq %r8, %r8
je 0x321e7
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x32267
subl %r15d, %ebp
movslq %r15d, %rax
leaq (%r14,%rax,8), %rsi
movl %ebp, %edi
callq 0xdeebd
movq %rax, %r14
callq 0xbe649
movq %r14, %rdi
movq %rax, %rsi
callq 0x12bf59
testq %rax, %rax
je 0x3223d
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102b93
movl %eax, %ebx
movq %r14, %rdi
callq 0x10297b
movq %r15, %rdi
callq 0x10297b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x405d24(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b2dc5(%rip), %rsi    # 0x2e5013
leaq 0x2be1dc(%rip), %rdx    # 0x2f0431
leaq 0x2be1aa(%rip), %rcx    # 0x2f0406
leaq 0x2be1b6(%rip), %r8     # 0x2f0419
pushq $0x33
jmp 0x3228f
movq 0x405cfa(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b2d9b(%rip), %rsi    # 0x2e5013
leaq 0x2b2f40(%rip), %rdx    # 0x2e51bf
leaq 0x2be180(%rip), %rcx    # 0x2f0406
leaq 0x2be18c(%rip), %r8     # 0x2f0419
pushq $0x2c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_magicmatch.c
// Function: gt_magicmatch_option_parser_new
static GtOptionParser* gt_magicmatch_option_parser_new(void *tool_arguments)
{
  MagicMatchArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *o;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] -f sequence_file [...] -t",
                         "Compute MD5 fingerprints for each sequence given in "
                         "sequence_file(s).");

  /* -f */
  o = gt_option_new_filename_array("f", "fasta file names (at least one file "
                                   "is required)", arguments->seqfiles);
  gt_option_is_mandatory(o);
  gt_option_parser_add_option(op, o);

  /* -t */
  o = gt_option_new_bool("t", "translate the sequences of the files",
                         &arguments->translate, false);
  gt_option_is_mandatory(o);
  gt_option_parser_add_option(op, o);

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
  gt_option_parser_set_min_max_args(op, 0, 0);

  return op;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x323b9
movq %rdi, %r14
leaq 0x2be154(%rip), %rdi    # 0x2f047a
leaq 0x2be174(%rip), %rsi    # 0x2f04a1
callq 0x97df5
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2cae0c(%rip), %rdi    # 0x2fd14b
leaq 0x2be1a1(%rip), %rsi    # 0x2f04e7
callq 0x9ad7e
movq %rax, %r15
movq %rax, %rdi
callq 0x9ae37
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
addq $0x8, %r14
leaq 0x332b1f(%rip), %rdi    # 0x364e8b
leaq 0x2be1a5(%rip), %rsi    # 0x2f0518
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r14
movq %rax, %rdi
callq 0x9ae37
movq %rbx, %rdi
movq %r14, %rsi
callq 0x97f31
leaq 0xb5152(%rip), %rsi     # 0xe74ec
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98045
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x98c6b
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x405ba8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b2c49(%rip), %rsi    # 0x2e5013
leaq 0x316282(%rip), %rdx    # 0x348653
leaq 0x2be082(%rip), %rcx    # 0x2f045a
leaq 0x2be061(%rip), %r8     # 0x2f0440
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_magicmatch.c
// Function: gt_magicmatch_runner
static int gt_magicmatch_runner(GT_UNUSED int argc, GT_UNUSED const char **argv,
                                GT_UNUSED int parsed_args, void *tool_arguments,
                                GtError *err)
{
  MagicMatchArguments *arguments = tool_arguments;
  GtBioseq *bioseq;
  GtUword i;
  int had_err = 0;

  gt_error_check(err);
  gt_assert(arguments);

  if (arguments->translate) {
    for (i = 0; !had_err && i < gt_str_array_size(arguments->seqfiles); i++) {
      if (!(bioseq = gt_bioseq_new(gt_str_array_get(arguments->seqfiles, i),
                                   err))) {
        had_err = -1;
      }
      if (!had_err)
        translate_sequence_file(bioseq);
      gt_bioseq_delete(bioseq);
    }
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r13
testq %r8, %r8
je 0x32418
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x32526
testq %r13, %r13
je 0x324fc
cmpb $0x1, 0x8(%r13)
jne 0x324e6
leaq 0x2f1fd6(%rip), %r15    # 0x324409
xorl %r12d, %r12d
xorl %r14d, %r14d
movq %rbx, 0x10(%rsp)
movq %r13, 0x8(%rsp)
testl %r14d, %r14d
jne 0x324ea
movq (%r13), %rdi
callq 0xae61c
cmpq %rax, %r12
jae 0x324e6
movq (%r13), %rdi
movq %r12, %rsi
callq 0xae386
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5a868
movq %rax, %r13
xorl %r14d, %r14d
testq %rax, %rax
sete 0x7(%rsp)
je 0x324c2
xorl %ebp, %ebp
movq %r13, %rdi
callq 0x5ba79
cmpq %rax, %rbp
jae 0x324c2
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5b9bf
movq %rax, %rbx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5b338
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
incq %rbp
jmp 0x32487
movb 0x7(%rsp), %al
movb %al, %r14b
negl %r14d
movq %r13, %rdi
callq 0x5af87
incq %r12
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r13
jmp 0x32443
xorl %eax, %eax
jmp 0x324ed
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x405a65(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b2b06(%rip), %rsi    # 0x2e5013
leaq 0x31613f(%rip), %rdx    # 0x348653
leaq 0x2be022(%rip), %rcx    # 0x2f053d
leaq 0x2bdf1e(%rip), %r8     # 0x2f0440
pushq $0x60
jmp 0x3254e
movq 0x405a3b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b2adc(%rip), %rsi    # 0x2e5013
leaq 0x2b2c81(%rip), %rdx    # 0x2e51bf
leaq 0x2bdff8(%rip), %rcx    # 0x2f053d
leaq 0x2bdef4(%rip), %r8     # 0x2f0440
pushq $0x5f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_matchtool.c
// Function: gt_matchtool_arguments_new
static void* gt_matchtool_arguments_new(void)
{
  GtMatchtoolArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->type = gt_str_new();
  arguments->matchfile = gt_str_new();
  arguments->query = gt_str_new();
  arguments->db = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2bdfc6(%rip), %rdx    # 0x2f0552
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
pushq $0x2e
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_matchtool.c
// Function: gt_matchtool_arguments_delete
static void gt_matchtool_arguments_delete(void *tool_arguments)
{
  GtMatchtoolArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->type);
  gt_str_delete(arguments->matchfile);
  gt_str_delete(arguments->query);
  gt_str_delete(arguments->db);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x32604
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
leaq 0x2bdf5a(%rip), %rsi    # 0x2f0552
pushq $0x3e
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_matstat.c
// Function: gt_matstat_arguments_delete
static void gt_matstat_arguments_delete(void *tool_arguments)
{
  Gfmsubcallinfo *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_array_delete(arguments->queryfilenames);
  gt_str_array_delete(arguments->flagsoutputoption);
  gt_str_delete(arguments->indexname);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x332c7
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0xae662
movq 0x38(%rbx), %rdi
callq 0xae662
movq 0x28(%rbx), %rdi
callq 0xae103
leaq 0x2bd785(%rip), %rsi    # 0x2f0a40
pushq $0x5d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_matstat.c
// Function: gt_matstat_arguments_new_generic
static void* gt_matstat_arguments_new_generic(bool doms)
{
  Gfmsubcallinfo *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->minlength.defined = false;
  arguments->maxlength.defined = false;
  arguments->showmode = 0;
  arguments->indexname = gt_str_new();
  arguments->queryfilenames = gt_str_array_new();
  arguments->flagsoutputoption = gt_str_array_new();
  arguments->doms = doms;
  return arguments;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x2bcfde(%rip), %rdx    # 0x2f0a40
pushq $0x1
popq %rdi
pushq $0x41
popq %rcx
movl $0x88, %esi
callq 0x9334a
movq %rax, %r14
xorl %eax, %eax
movb %al, (%r14)
movb %al, 0x10(%r14)
andl $0x0, 0x20(%r14)
callq 0xacb84
movq %rax, 0x28(%r14)
callq 0xae154
movq %rax, 0x30(%r14)
callq 0xae154
movq %rax, 0x38(%r14)
movb %bl, 0x44(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_md5_to_id.c
// Function: gt_md5_to_id_arguments_new
static void *gt_md5_to_id_arguments_new(void)
{
  MD5ToSeqidsArguments *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 0x2bd26e(%rip), %rdx    # 0x2f0d49
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x26
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x116724
movq %rax, 0x8(%rbx)
callq 0x9b6b4
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_md5_to_id.c
// Function: gt_md5_to_id_arguments_delete
static void gt_md5_to_id_arguments_delete(void *tool_arguments)
{
  MD5ToSeqidsArguments *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 0x33b3a
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
movq 0x8(%rbx), %rdi
callq 0x116765
leaq 0x2bd21b(%rip), %rsi    # 0x2f0d49
pushq $0x33
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_md5_to_id.c
// Function: gt_md5_to_id_option_parser_new
static GtOptionParser* gt_md5_to_id_option_parser_new(void *tool_arguments)
{
  MD5ToSeqidsArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[option ...] [GFF3_file ...]",
                            "Change MD5 fingerprints used as sequence IDs in "
                            "given GFF3 files to ``regular'' ones.");

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

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

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x33b9f
movq %rdi, %rbx
leaq 0x2b69ab(%rip), %rdi    # 0x2ea4f9
leaq 0x2bd22c(%rip), %rsi    # 0x2f0d81
callq 0x97df5
movq %rax, %r14
movq 0x8(%rbx), %rsi
pushq $0x1
popq %rcx
movq %rax, %rdi
xorl %edx, %edx
callq 0x1167a5
movq %rbx, %rdi
callq 0x9a9b6
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x4043c2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b1463(%rip), %rsi    # 0x2e5013
leaq 0x314a9c(%rip), %rdx    # 0x348653
leaq 0x2bd1a4(%rip), %rcx    # 0x2f0d62
leaq 0x2bd184(%rip), %r8     # 0x2f0d49
pushq $0x3b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_merge.c
// Function: gt_merge_arguments_delete
static void gt_merge_arguments_delete(void *tool_arguments)
{
  MergeArguments *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 0x33d82
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x8da06
movq (%rbx), %rdi
callq 0x9ba24
leaq 0x2bd075(%rip), %rsi    # 0x2f0deb
pushq $0x30
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_merge.c
// Function: gt_merge_option_parser_new
static GtOptionParser* gt_merge_option_parser_new(void *tool_arguments)
{
  MergeArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);
  op = gt_option_parser_new("[option ...] [GFF3_file ...]",
                         "Merge sorted GFF3 files in sorted fashion.");

  /* -retainids */
  option = gt_option_new_bool("retainids",
                              "when available, use the original IDs provided "
                              "in the source file\n"
                              "(memory consumption is proportional to the "
                              "input file size(s))", &arguments->retainids,
                              false);
  gt_option_parser_add_option(op, option);

  /* -tidy */
  option = gt_option_new_bool("tidy", "try to tidy the GFF3 files up "
                              "during parsing", &arguments->tidy, false);
  gt_option_parser_add_option(op, option);

  gt_output_file_info_register_options(arguments->ofi, op, &arguments->outfp);
  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x33e0a
movq %rdi, %rbx
leaq 0x2b6763(%rip), %rdi    # 0x2ea4f9
leaq 0x2bd07e(%rip), %rsi    # 0x2f0e1b
callq 0x97df5
movq %rax, %r14
leaq 0x10(%rbx), %rdx
leaq 0x34c9fb(%rip), %rdi    # 0x3807ab
leaq 0x2b9d83(%rip), %rsi    # 0x2edb3a
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x11(%rbx), %rdx
leaq 0x2ec0f7(%rip), %rdi    # 0x31fecb
leaq 0x2b9d32(%rip), %rsi    # 0x2edb0d
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq (%rbx), %rdi
addq $0x8, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x404157(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b11f8(%rip), %rsi    # 0x2e5013
leaq 0x314831(%rip), %rdx    # 0x348653
leaq 0x2bcfd7(%rip), %rcx    # 0x2f0e00
leaq 0x2bcfbb(%rip), %r8     # 0x2f0deb
pushq $0x38
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_mergefeat.c
// Function: gt_mergefeat_arguments_delete
static void gt_mergefeat_arguments_delete(void *tool_arguments)
{
  InterFeatArguments *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 0x342b2
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x8da06
movq (%rbx), %rdi
callq 0x9ba24
leaq 0x2bcc85(%rip), %rsi    # 0x2f0f2b
pushq $0x2b
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_mergefeat.c
// Function: gt_mergefeat_option_parser_new
static GtOptionParser* gt_mergefeat_option_parser_new(void *tool_arguments)
{
  InterFeatArguments *arguments = tool_arguments;
  GtOptionParser *op;

  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file ...]", "Merge adjacent "
                            "features without children of the same type in "
                            "given GFF3 file(s).");

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

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x342f2
movq %rdi, %rbx
leaq 0x2b6233(%rip), %rdi    # 0x2ea4f9
leaq 0x2bcc96(%rip), %rsi    # 0x2f0f63
callq 0x97df5
movq %rax, %r14
movq (%rbx), %rdi
addq $0x8, %rbx
movq %rax, %rsi
movq %rbx, %rdx
callq 0x9b6d7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x403c6f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b0d10(%rip), %rsi    # 0x2e5013
leaq 0x314349(%rip), %rdx    # 0x348653
leaq 0x2bcc33(%rip), %rcx    # 0x2f0f44
leaq 0x2bcc13(%rip), %r8     # 0x2f0f2b
pushq $0x33
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_mergefeat.c
// Function: gt_mergefeat_runner
static int gt_mergefeat_runner(int argc, const char **argv, int parsed_args,
                          void *tool_arguments, GtError *err)
{
  InterFeatArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream,
               *merge_feature_stream,
               *gff3_out_stream;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create a gff3 input stream */
  gff3_in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
                                                  argv + parsed_args);

  /* create merge feature stream */
  merge_feature_stream = gt_merge_feature_stream_new(gff3_in_stream);

  /* create gff3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(merge_feature_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(merge_feature_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, %r12d
movq %rsi, %r15
movl %edi, %ebp
testq %r8, %r8
je 0x34353
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x343e0
testq %r14, %r14
je 0x343b6
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r15,%rax,8), %rsi
movl %ebp, %edi
callq 0xdeebd
movq %rax, %r15
movq %rax, %rdi
callq 0x100618
movq %rax, %r12
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0xe07df
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102b93
movl %eax, %ebx
movq %r14, %rdi
callq 0x10297b
movq %r12, %rdi
callq 0x10297b
movq %r15, %rdi
callq 0x10297b
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x403bab(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b0c4c(%rip), %rsi    # 0x2e5013
leaq 0x314285(%rip), %rdx    # 0x348653
leaq 0x2bcbdf(%rip), %rcx    # 0x2f0fb4
leaq 0x2bcb4f(%rip), %r8     # 0x2f0f2b
pushq $0x4a
jmp 0x34408
movq 0x403b81(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b0c22(%rip), %rsi    # 0x2e5013
leaq 0x2b0dc7(%rip), %rdx    # 0x2e51bf
leaq 0x2bcbb5(%rip), %rcx    # 0x2f0fb4
leaq 0x2bcb25(%rip), %r8     # 0x2f0f2b
pushq $0x49
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_mkfeatureindex.c
// Function: gt_mkfeatureindex_arguments_new
static void* gt_mkfeatureindex_arguments_new(void)
{
  GtMkfeatureindexArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->backend = gt_str_new();
  arguments->filename = gt_str_new();
  arguments->host = gt_str_new();
  arguments->user = gt_str_new();
  arguments->pass = gt_str_new();
  arguments->database = gt_str_new();
  arguments->input = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2bcb38(%rip), %rdx    # 0x2f0fe4
pushq $0x1
popq %rdi
pushq $0x40
popq %rsi
pushq $0x38
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
callq 0xacb84
movq %rax, 0x28(%rbx)
callq 0xacb84
movq %rax, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_mkfeatureindex.c
// Function: gt_mkfeatureindex_arguments_delete
static void gt_mkfeatureindex_arguments_delete(void *tool_arguments)
{
  GtMkfeatureindexArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->backend);
  gt_str_delete(arguments->filename);
  gt_str_delete(arguments->host);
  gt_str_delete(arguments->user);
  gt_str_delete(arguments->pass);
  gt_str_delete(arguments->database);
  gt_str_delete(arguments->input);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x3455a
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0x20(%rbx), %rdi
callq 0xae103
movq 0x28(%rbx), %rdi
callq 0xae103
movq 0x30(%rbx), %rdi
callq 0xae103
leaq 0x2bca96(%rip), %rsi    # 0x2f0fe4
pushq $0x4e
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq