LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x2a975b(%rip), %rdi    # 0x358352
leaq 0x2a976e(%rip), %rsi    # 0x35836c
callq 0x10cc4e
movq %rax, %r14
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x17b366
movq 0x8(%rbx), %rdi
addq $0x10, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_inlineseq_add.c
// Function: gt_inlineseq_add_runner
static int gt_inlineseq_add_runner(int argc, const char **argv, int parsed_args,
                               void *tool_arguments, GtError *err)
{
  GtNodeStream *gff3_in_stream = NULL,
               *add_stream = NULL,
               *gff3_out_stream = NULL,
               *last_stream = NULL;
  GtRegionMapping *rm = NULL;
  InlineseqAddArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);

  /* add region mapping if given */
  if (gt_seqid2file_option_used(arguments->s2fi)) {
    rm = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
    if (!rm)
      had_err = -1;
  }

  if (!had_err) {
    last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted(
                                                            argc - parsed_args,
                                                            argv + parsed_args);
    gt_assert(gff3_in_stream);
    gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream);

    last_stream = add_stream = gt_sequence_node_add_stream_new(last_stream, rm,
                                                               err);
    if (!add_stream) {
      had_err = -1;
    }
  }

  if (!had_err) {
    last_stream = gff3_out_stream = gt_gff3_out_stream_new(last_stream,
                                                           arguments->outfp);
  }

  if (!had_err)
    had_err = gt_node_stream_pull(last_stream, err);

  /* free */
  gt_node_stream_delete(gff3_in_stream);
  gt_node_stream_delete(add_stream);
  gt_node_stream_delete(gff3_out_stream);
  gt_region_mapping_delete(rm);

  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, %r13d
movq %rsi, %r12
movl %edi, %ebp
testq %r8, %r8
je 0xaec5d
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xaed39
movq (%r15), %rdi
callq 0x17b372
testb %al, %al
je 0xaec7f
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x17b3bd
movq %rax, %r14
testq %rax, %rax
setne %al
jmp 0xaec84
movb $0x1, %al
xorl %r14d, %r14d
testb %al, %al
movq %r14, (%rsp)
je 0xaeccb
subl %r13d, %ebp
movslq %r13d, %rax
leaq (%r12,%rax,8), %rsi
movl %ebp, %edi
callq 0x14d00b
testq %rax, %rax
je 0xaed3e
movq %rax, %r12
movq %rax, %rdi
callq 0x14cfc0
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17c3bb
movq %rax, %r13
testq %rax, %rax
setne %r14b
jmp 0xaecd4
xorl %r13d, %r13d
xorl %r12d, %r12d
xorl %r14d, %r14d
testb %r14b, %r14b
je 0xaeced
movq 0x10(%r15), %rsi
movq %r13, %rdi
callq 0x14e310
movq %rax, %r15
movq %rax, %rdi
jmp 0xaecf3
xorl %r15d, %r15d
movq %r13, %rdi
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %r14b, %r14b
je 0xaed07
movq %rbx, %rsi
callq 0x16adca
movl %eax, %ebp
movq %r12, %rdi
callq 0x16ac6e
movq %r13, %rdi
callq 0x16ac6e
movq %r15, %rdi
callq 0x16ac6e
movq (%rsp), %rdi
callq 0x1758da
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1be8c
callq 0x1bec3
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2a965e(%rip), %rdx    # 0x3583cd
movl $0x1, %edi
movl $0x10, %esi
movl $0x26, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaedcb
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
leaq 0x2a9610(%rip), %rsi    # 0x3583cd
movq %rbx, %rdi
movl $0x32, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaee50
movq %rdi, %r14
leaq 0x2a9631(%rip), %rdi    # 0x358411
leaq 0x2a9662(%rip), %rsi    # 0x358449
callq 0x10cc4e
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2f847c(%rip), %rdi    # 0x3a7275
leaq 0x2a968b(%rip), %rsi    # 0x35848b
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x8(%r14), %rdx
leaq 0x2d7911(%rip), %rdi    # 0x386731
leaq 0x2a9687(%rip), %rsi    # 0x3584ae
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
movq %r14, %rsi
callq 0x10faa6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1befa
// File: /workspace/github_c_makefile_star2_O1/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 0x2a9502(%rip), %rdx    # 0x3584f9
movl $0x1, %edi
movl $0x20, %esi
movl $0x22, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x10ff7c
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaf06e
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040fc
movq 0x10(%rbx), %rdi
callq 0x110231
movq 0x8(%rbx), %rdi
callq 0x121b03
movq (%rbx), %rdi
callq 0x121b03
leaq 0x2a9499(%rip), %rsi    # 0x3584f9
movq %rbx, %rdi
movl $0x31, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xaf104
movq %rdi, %rbx
leaq 0x2a4483(%rip), %rdi    # 0x353509
leaq 0x2a9485(%rip), %rsi    # 0x358512
callq 0x10cc4e
movq %rax, %r14
movq (%rbx), %rdx
leaq 0x31b833(%rip), %rdi    # 0x3ca8d2
leaq 0x2a94b6(%rip), %rsi    # 0x35855c
leaq 0x2eeb91(%rip), %rcx    # 0x39dc3e
callq 0x10f987
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x8(%rbx), %rdx
leaq 0x33196f(%rip), %rdi    # 0x3e0a37
leaq 0x2a949e(%rip), %rsi    # 0x35856d
leaq 0x2ee66c(%rip), %rcx    # 0x39d742
callq 0x10f987
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1c00d
// File: /workspace/github_c_makefile_star2_O1/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 0xaf134
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xaf1b6
testq %r14, %r14
je 0xaf1b1
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r15,%rax,8), %rsi
movl %ebp, %edi
callq 0x14d00b
movq %rax, %r15
movq (%r14), %rdi
callq 0x120d23
movq %rax, %r12
movq 0x8(%r14), %rdi
callq 0x120d23
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x15de84
movq %rax, %r12
movq 0x18(%r14), %rsi
movq %rax, %rdi
callq 0x14e310
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16adca
movl %eax, %ebx
movq %r14, %rdi
callq 0x16ac6e
movq %r12, %rdi
callq 0x16ac6e
movq %r15, %rdi
callq 0x16ac6e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c07b
callq 0x1c044
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xaf4b6
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xaf503
testq %r14, %r14
je 0xaf4fe
cmpl $0x1, %ebp
jne 0xaf4e3
movq 0x20(%r14), %rdi
callq 0x120d4c
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xaf4f9
cmpb $0x0, 0x18(%r14)
jne 0xaf4f9
leaq 0x2a9498(%rip), %rsi    # 0x358979
jmp 0xaf4ea
leaq 0x2a9470(%rip), %rsi    # 0x35895a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %rbp
retq
callq 0x1c122
callq 0x1c0e9
// File: /workspace/github_c_makefile_star2_O1/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 0x2a8dac(%rip), %rdx    # 0x358a90
movl $0x1, %edi
movl $0x50, %esi
movl $0x54, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x121b54
movq %rax, 0x8(%rbx)
callq 0x121b54
movq %rax, 0x10(%rbx)
callq 0x121b54
movq %rax, 0x18(%rbx)
callq 0x121b54
movq %rax, 0x20(%rbx)
callq 0x121b54
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xafd88
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121e8b
movq 0x10(%rbx), %rdi
callq 0x121e8b
movq 0x18(%rbx), %rdi
callq 0x121e8b
movq 0x20(%rbx), %rdi
callq 0x121e8b
movq 0x28(%rbx), %rdi
callq 0x121e8b
leaq 0x2a8d16(%rip), %rsi    # 0x358a90
movq %rbx, %rdi
movl $0x68, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb0f39
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x103703
movq %rax, %r15
leaq 0x1ae(%rip), %rdx       # 0xb10c3
movq %rax, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
movq %r14, %r8
movq %rbx, %r9
callq 0x1032b8
movl %eax, %ebx
movq %r15, %rdi
callq 0x10327d
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1c4b2
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0x8(%rsi)
je 0xb0f94
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movq (%rbx), %rax
movq (%rax,%r13,8), %r15
movq %r15, %rdi
callq 0x120d23
movq %rax, %r12
movq %r15, %rdi
callq 0x120d4c
movq %r14, %rdi
movq %r12, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0xd3df3
incq %r13
cmpq 0x8(%rbx), %r13
jb 0xb0f57
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb1072
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xb1044
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x121b03
incq %r14
cmpq 0x8(%rbx), %r14
jb 0xb102f
movq (%rbx), %rdi
leaq 0x2a7a42(%rip), %r14    # 0x358a90
movq %r14, %rsi
movl $0x80, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x81, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a7a12(%rip), %rbx    # 0x358a90
movl $0x18, %edi
movq %rbx, %rsi
movl $0x70, %edx
callq 0x1092b2
movq %rax, %r14
movl $0x8, %edi
movq %rbx, %rsi
movl $0x71, %edx
callq 0x1092b2
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movq $0x1, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb10fe
leaq 0xa(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq (%rbx), %rdi
leaq 0x50(,%rax,8), %rsi
leaq 0x2a799f(%rip), %rdx    # 0x358a90
movl $0x1cf, %ecx            # imm = 0x1CF
callq 0x1094e6
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x120955
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_O1/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 0x339a27(%rip), %rdi    # 0x3eaccd
movl $0x1, %r13d
movl $0x7, %esi
movl $0x1, %edx
movq %r8, %rcx
callq 0x17fa0
testq %r14, %r14
je 0xb136d
xorl %ebp, %ebp
movq %r13, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
mulq %rcx
movq 0x10(%rsp), %rax
movb (%rax,%rbp), %cl
testq %r12, %r12
je 0xb12f8
movl 0xc(%rsp), %eax
cmpb $-0x3, %cl
ja 0xb12fa
movzbl %cl, %eax
movb (%r12,%rax), %al
jmp 0xb12fa
movl %ecx, %eax
shrq $0x6, %rdx
leaq (%rdx,%rdx,4), %r15
shlq $0x4, %r15
decq %r15
movzbl %al, %edi
movq %rbx, %rsi
callq 0x17980
cmpq %rbp, %r15
jne 0xb1326
movl $0xa, %edi
movq %rbx, %rsi
callq 0x17980
incq %rbp
incq %r13
cmpq %rbp, %r14
jne 0xb12c9
movabsq $-0x3333333333333333, %rax # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r14
rorq $0x4, %r14
movabsq $0x333333333333334, %rax # imm = 0x333333333333334
cmpq %rax, %r14
jb 0xb136d
movl $0xa, %edi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17980
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb13cb
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb1426
subl %r15d, %ebp
movslq %r15d, %rax
leaq (%r14,%rax,8), %rsi
movl %ebp, %edi
callq 0x14d00b
movq %rax, %r14
callq 0x12eb11
movq %r14, %rdi
movq %rax, %rsi
callq 0x18c917
testq %rax, %rax
je 0xb1421
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16adca
movl %eax, %ebx
movq %r14, %rdi
callq 0x16ac6e
movq %r15, %rdi
callq 0x16ac6e
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c522
callq 0x1c4eb
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb154d
movq %rdi, %r14
leaq 0x2a7fe8(%rip), %rdi    # 0x3594a2
leaq 0x2a8008(%rip), %rsi    # 0x3594c9
callq 0x10cc4e
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x2b4dc2(%rip), %rdi    # 0x366295
leaq 0x2a8035(%rip), %rsi    # 0x35950f
callq 0x10f9f6
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
addq $0x8, %r14
leaq 0x31cca3(%rip), %rdi    # 0x3ce1a3
leaq 0x2a8039(%rip), %rsi    # 0x359540
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r14
movq %rax, %rdi
callq 0x10fa96
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10cd10
leaq 0xa296e(%rip), %rsi     # 0x153e9c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10cd8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d784
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x1c559
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
testq %r8, %r8
je 0xb1578
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb164f
testq %r14, %r14
je 0xb164a
xorl %eax, %eax
cmpb $0x1, 0x8(%r14)
jne 0xb163b
leaq 0x2dbe2c(%rip), %r12    # 0x38d3c1
xorl %r13d, %r13d
movq %r14, (%rsp)
movq (%r14), %rdi
callq 0x121e78
cmpq %rax, %r13
jae 0xb1639
movq (%r14), %rdi
movq %r13, %rsi
callq 0x121cfa
movq %rax, %rdi
movq %rbx, %r14
movq %rbx, %rsi
callq 0xd69c0
movq %rax, %rbp
testq %rax, %rax
je 0xb1617
movq %rbp, %rdi
callq 0xd75d2
testq %rax, %rax
je 0xb1617
xorl %r15d, %r15d
movq %rbp, %rdi
movq %r15, %rsi
callq 0xd7571
movq %rax, %rbx
movq %rbp, %rdi
movq %r15, %rsi
callq 0xd71c2
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17070
incq %r15
movq %rbp, %rdi
callq 0xd75d2
cmpq %rax, %r15
jb 0xb15de
movq %rbp, %rdi
callq 0xd6f28
incq %r13
testq %rbp, %rbp
movq %r14, %rbx
movq (%rsp), %r14
jne 0xb159c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xb163b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c5c7
callq 0x1c590
// File: /workspace/github_c_makefile_star2_O1/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 0x2a7ef6(%rip), %rdx    # 0x35957a
movl $0x1, %edi
movl $0x30, %esi
movl $0x2e, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb1704
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121b03
leaq 0x2a7e84(%rip), %rsi    # 0x35957a
movq %rbx, %rdi
movl $0x3e, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb22ff
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x121e8b
movq 0x38(%rbx), %rdi
callq 0x121e8b
movq 0x28(%rbx), %rdi
callq 0x121b03
leaq 0x2a7777(%rip), %rsi    # 0x359a68
movq %rbx, %rdi
movl $0x5d, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2a7084(%rip), %rdx    # 0x359a68
movl $0x1, %edi
movl $0x88, %esi
movl $0x41, %ecx
callq 0x1093ef
movq %rax, %r14
xorl %eax, %eax
movb %al, (%r14)
movb %al, 0x10(%r14)
movl $0x0, 0x20(%r14)
callq 0x1208f8
movq %rax, 0x28(%r14)
callq 0x121b54
movq %rax, 0x30(%r14)
callq 0x121b54
movq %rax, 0x38(%r14)
movb %bl, 0x44(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2a730e(%rip), %rdx    # 0x359d71
movl $0x1, %edi
movl $0x20, %esi
movl $0x26, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x17b020
movq %rax, 0x8(%rbx)
callq 0x10ff7c
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb2aca
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1040fc
movq 0x10(%rbx), %rdi
callq 0x110231
movq 0x8(%rbx), %rdi
callq 0x17b067
leaq 0x2a72b5(%rip), %rsi    # 0x359d71
movq %rbx, %rdi
movl $0x33, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb2b31
movq %rdi, %rbx
leaq 0x2a0a2b(%rip), %rdi    # 0x353509
leaq 0x2a72c4(%rip), %rsi    # 0x359da9
callq 0x10cc4e
movq %rax, %r14
movq 0x8(%rbx), %rsi
movq %rax, %rdi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x17b0a9
movq %rbx, %rdi
callq 0x10f473
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x10(%rbx), %rdi
addq $0x18, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1c8a6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_md5_to_id.c
// Function: gt_md5_to_id_runner
static int gt_md5_to_id_runner(GT_UNUSED int argc, const char **argv,
                                   int parsed_args, void *tool_arguments,
                                   GtError *err)
{
  GtNodeStream *gff3_in_stream, *md5_to_id_stream = NULL,
               *gff3_out_stream = NULL;
  MD5ToSeqidsArguments *arguments = tool_arguments;
  GtRegionMapping *region_mapping = NULL;
  int had_err = 0;

  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);
  if (arguments->verbose && arguments->outfp)
    gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);

  /* create region mapping */
  if (gt_seqid2file_option_used(arguments->s2fi)) {
    region_mapping = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
    if (!region_mapping)
      had_err = -1;
  }

  if (!had_err) {
    /* create seqid to md5 stream */
    md5_to_id_stream = gt_md5_to_id_stream_new(gff3_in_stream, region_mapping);

    /* create gff3 output stream */
    gff3_out_stream = gt_gff3_out_stream_new(md5_to_id_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(md5_to_id_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, %r15
movl %edx, %r12d
movq %rsi, %r14
movl %edi, %ebp
testq %r8, %r8
je 0xb2b61
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb2c1b
testq %r15, %r15
je 0xb2c16
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r14,%rax,8), %rsi
movl %ebp, %edi
callq 0x14d00b
movq %rax, %r14
cmpb $0x1, (%r15)
jne 0xb2b93
cmpq $0x0, 0x18(%r15)
je 0xb2b93
movq %r14, %rdi
callq 0x14ce62
movq 0x8(%r15), %rdi
callq 0x17b372
testb %al, %al
je 0xb2bb4
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x17b3bd
testq %rax, %rax
setne %cl
jmp 0xb2bb8
movb $0x1, %cl
xorl %eax, %eax
testb %cl, %cl
je 0xb2be8
movq %r14, %rdi
movq %rax, %rsi
callq 0x1684c4
movq %rax, %r12
movq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x14e310
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16adca
movl %eax, %ebx
jmp 0xb2bf3
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x16ac6e
movq %r12, %rdi
callq 0x16ac6e
movq %r14, %rdi
callq 0x16ac6e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c914
callq 0x1c8dd
// File: /workspace/github_c_makefile_star2_O1/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 0xb2c9e
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1040fc
movq (%rbx), %rdi
callq 0x110231
leaq 0x2a7183(%rip), %rsi    # 0x359e13
movq %rbx, %rdi
movl $0x30, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb2d26
movq %rdi, %rbx
leaq 0x2a0857(%rip), %rdi    # 0x353509
leaq 0x2a718a(%rip), %rsi    # 0x359e43
callq 0x10cc4e
movq %rax, %r14
leaq 0x10(%rbx), %rdx
leaq 0x336e1f(%rip), %rdi    # 0x3e9aeb
leaq 0x2a3e97(%rip), %rsi    # 0x356b6a
xorl %ecx, %ecx
callq 0x10f451
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x11(%rbx), %rdx
leaq 0x2d6177(%rip), %rdi    # 0x388e67
leaq 0x2a3e46(%rip), %rsi    # 0x356b3d
xorl %ecx, %ecx
callq 0x10f451
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cd10
movq (%rbx), %rdi
addq $0x8, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1c94b
// File: /workspace/github_c_makefile_star2_O1/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 0xb3102
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x1040fc
movq (%rbx), %rdi
callq 0x110231
leaq 0x2a6e5f(%rip), %rsi    # 0x359f53
movq %rbx, %rdi
movl $0x2b, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb3142
movq %rdi, %rbx
leaq 0x2a03f3(%rip), %rdi    # 0x353509
leaq 0x2a6e6e(%rip), %rsi    # 0x359f8b
callq 0x10cc4e
movq %rax, %r14
movq (%rbx), %rdi
addq $0x8, %rbx
movq %rax, %rsi
movq %rbx, %rdx
callq 0x10ffa3
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1ca95
// File: /workspace/github_c_makefile_star2_O1/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 0xb316e
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb31d6
testq %r14, %r14
je 0xb31d1
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r15,%rax,8), %rsi
movl %ebp, %edi
callq 0x14d00b
movq %rax, %r15
movq %rax, %rdi
callq 0x168f88
movq %rax, %r12
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x14e310
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16adca
movl %eax, %ebx
movq %r14, %rdi
callq 0x16ac6e
movq %r12, %rdi
callq 0x16ac6e
movq %r15, %rdi
callq 0x16ac6e
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1cb03
callq 0x1cacc
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x2a6dcc(%rip), %rdx    # 0x35a00c
movl $0x1, %edi
movl $0x40, %esi
movl $0x38, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x1208f8
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x8(%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
movq %rax, 0x18(%rbx)
callq 0x1208f8
movq %rax, 0x20(%rbx)
callq 0x1208f8
movq %rax, 0x28(%rbx)
callq 0x1208f8
movq %rax, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb32f6
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x121b03
movq 0x8(%rbx), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121b03
movq 0x20(%rbx), %rdi
callq 0x121b03
movq 0x28(%rbx), %rdi
callq 0x121b03
movq 0x30(%rbx), %rdi
callq 0x121b03
leaq 0x2a6d24(%rip), %rsi    # 0x35a00c
movq %rbx, %rdi
movl $0x4e, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_mkfeatureindex.c
// Function: gt_mkfeatureindex_arguments_check
static int gt_mkfeatureindex_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  GT_UNUSED GtMkfeatureindexArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  return had_err;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
testq %rdx, %rdx
je 0xb340a
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0xb3418
testq %rbx, %rbx
je 0xb3413
xorl %eax, %eax
popq %rbx
retq
callq 0x1cbe1
callq 0x1cba8