LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x3f3f3
movq 0x5fcbde(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d6c47(%rip), %rsi    # 0x516013
leaq 0x53b78c(%rip), %rdx    # 0x57ab5f
leaq 0x4dc149(%rip), %rcx    # 0x51b523
leaq 0x4e1178(%rip), %r8     # 0x520559
movl $0x3a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x3f3f5
leaq 0x4dc146(%rip), %rdi    # 0x51b542
leaq 0x4e116f(%rip), %rsi    # 0x520572
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdx
leaq 0x5550e0(%rip), %rdi    # 0x5944fc
leaq 0x4e1199(%rip), %rsi    # 0x5205bc
leaq 0x527cf2(%rip), %rcx    # 0x56711c
callq 0xf69f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x56d320(%rip), %rdi    # 0x5ac773
leaq 0x4e1173(%rip), %rsi    # 0x5205cd
leaq 0x5277bf(%rip), %rcx    # 0x566c20
callq 0xf69f0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x3f515
movq 0x40(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x3f4dd
jmp 0x3f515
movq 0x5fcabc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d6b25(%rip), %rsi    # 0x516013
leaq 0x4d6cca(%rip), %rdx    # 0x5161bf
leaq 0x4dc0be(%rip), %rcx    # 0x51b5ba
leaq 0x4e1056(%rip), %r8     # 0x520559
movl $0x5a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x3f517
jmp 0x3f519
cmpq $0x0, 0x38(%rsp)
jne 0x3f559
movq 0x5fca78(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d6ae1(%rip), %rsi    # 0x516013
leaq 0x53b626(%rip), %rdx    # 0x57ab5f
leaq 0x4dc07a(%rip), %rcx    # 0x51b5ba
leaq 0x4e1012(%rip), %r8     # 0x520559
movl $0x5b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x3f55b
movl 0x64(%rsp), %edi
subl 0x54(%rsp), %edi
movq 0x58(%rsp), %rsi
movslq 0x54(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1746b0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rdi
callq 0x11dee0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11dee0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x195fe0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x176d50
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1b1f90
movl %eax, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1b1cb0
movq 0x28(%rsp), %rdi
callq 0x1b1cb0
movq 0x30(%rsp), %rdi
callq 0x1b1cb0
movl 0x1c(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_kmer_database.c
// Function: gt_kmer_database_arguments_delete
static void gt_kmer_database_arguments_delete(void *tool_arguments)
{
  GtKmerDatabaseArguments *arguments = tool_arguments;
  if (arguments != NULL) {
    gt_str_delete(arguments->print_filename);
    gt_free(arguments);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3f6cf
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4e0f1e(%rip), %rsi    # 0x5205e3
movl $0x40, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x3fa94
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x3fa5c
jmp 0x3fa94
movq 0x5fc53d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d65a6(%rip), %rsi    # 0x516013
leaq 0x4d674b(%rip), %rdx    # 0x5161bf
leaq 0x4e0f01(%rip), %rcx    # 0x52097c
leaq 0x4e0b61(%rip), %r8     # 0x5205e3
movl $0xac, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x3fa96
jmp 0x3fa98
cmpq $0x0, 0x8(%rsp)
jne 0x3fad8
movq 0x5fc4f9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d6562(%rip), %rsi    # 0x516013
leaq 0x53b0a7(%rip), %rdx    # 0x57ab5f
leaq 0x4e0ebd(%rip), %rcx    # 0x52097c
leaq 0x4e0b1d(%rip), %r8     # 0x5205e3
movl $0xad, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x3fada
cmpl $0x1, 0x24(%rsp)
je 0x3fafc
movq 0x10(%rsp), %rdi
leaq 0x4e0eb0(%rip), %rsi    # 0x52099d
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
cmpl $0x0, 0x4(%rsp)
jne 0x3fb3f
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11dfa0
cmpq $0x0, %rax
jbe 0x3fb3f
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
jne 0x3fb3d
movq 0x10(%rsp), %rdi
leaq 0x4e0e8e(%rip), %rsi    # 0x5209bc
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x3fb3f
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x50, %esi
leaq 0x4e002e(%rip), %rdx    # 0x520ac0
movl $0x54, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x40b94
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4dff36(%rip), %rsi    # 0x520ac0
movl $0x68, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x41d4b
movq 0x5fa286(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d42ef(%rip), %rsi    # 0x516013
leaq 0x4df5b0(%rip), %rdx    # 0x5212db
leaq 0x4df5c0(%rip), %rcx    # 0x5212f2
leaq 0x4ded87(%rip), %r8     # 0x520ac0
movl $0x1dd, %r9d            # imm = 0x1DD
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x41d4d
movq 0x18(%rsp), %rdi
callq 0xdc9e0
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x20(%rsp), %r8
movq 0x10(%rsp), %r9
xorl %eax, %eax
movl %eax, %ecx
leaq 0xfac(%rip), %rdx       # 0x42d20
movq %rcx, %rsi
callq 0xdc550
movl %eax, 0xc(%rsp)
movq (%rsp), %rdi
callq 0xdc4c0
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x41e3e
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11dee0
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11dfa0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rax, %rcx
callq 0x7f850
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x41db7
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: gt_parse_score_value
static int gt_parse_score_value(int line,GtWord *value,const char* str,
                                GT_UNUSED bool non_negative, GtError *err)
{
  if (sscanf(str, GT_WD, value) != 1 || (non_negative && *value < 0))
  {
    gt_error_set(err,"line %d: invalid %s value \"%s\"",line,
                 non_negative ? "cost" : "score",str);
    return -1;
  }
  return 0;
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq %r8, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x50c640(%rip), %rsi    # 0x54e86f
movb $0x0, %al
callq 0x19770
cmpl $0x1, %eax
jne 0x4224d
testb $0x1, 0xf(%rsp)
je 0x4228d
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
jge 0x4228d
movq (%rsp), %rdi
movl 0x20(%rsp), %edx
movb 0xf(%rsp), %sil
leaq 0x53880a(%rip), %rcx    # 0x57aa6b
leaq 0x4dec08(%rip), %rax    # 0x520e70
testb $0x1, %sil
cmovneq %rax, %rcx
movq 0x10(%rsp), %r8
leaq 0x4df0a3(%rip), %rsi    # 0x52131f
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x42295
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x42caf
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x42c80
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x42c4a
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x4dde31(%rip), %rsi    # 0x520ac0
movl $0x80, %edx
callq 0xe88c0
movq 0x10(%rsp), %rdi
leaq 0x4dde1b(%rip), %rsi    # 0x520ac0
movl $0x81, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x18, %edi
leaq 0x4dddf3(%rip), %rsi    # 0x520ac0
movl $0x70, %edx
callq 0xe80f0
movq %rax, (%rsp)
movl $0x8, %edi
leaq 0x4dddd9(%rip), %rsi    # 0x520ac0
movl $0x71, %edx
callq 0xe80f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x1, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x42d91
movq (%rsp), %rax
movq 0x10(%rax), %rcx
addq $0xa, %rcx
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rsi
shlq $0x3, %rsi
leaq 0x4ddd43(%rip), %rdx    # 0x520ac0
movl $0x1cf, %ecx            # imm = 0x1CF
callq 0xe8540
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
callq 0x11d510
movq %rax, %rdx
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rsi
movq 0x8(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x8(%rsi)
movq %rdx, (%rax,%rcx,8)
xorl %eax, %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq $0x50, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x573c34(%rip), %rsi    # 0x5b6be8
movb $0x0, %al
callq 0x199f0
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x43076
cmpq $0x0, 0x40(%rsp)
jne 0x42fef
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
jmp 0x4302a
movq 0x30(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0xfe, %eax
jl 0x4300e
movb 0x3f(%rsp), %al
movb %al, 0xf(%rsp)
jmp 0x43028
movq 0x40(%rsp), %rax
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
jmp 0x4302a
movzbl 0xf(%rsp), %edi
movq 0x20(%rsp), %rsi
callq 0x198d0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movl $0x50, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jne 0x43061
movq 0x20(%rsp), %rsi
movl $0xa, %edi
callq 0x198d0
jmp 0x43063
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x42fc4
movq 0x10(%rsp), %rax
movl $0x50, %ecx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
je 0x4309a
movq 0x20(%rsp), %rsi
movl $0xa, %edi
callq 0x198d0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x43175
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4313d
jmp 0x43175
movq 0x5f8e5c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d2ec5(%rip), %rsi    # 0x516013
leaq 0x4d306a(%rip), %rdx    # 0x5161bf
leaq 0x4de302(%rip), %rcx    # 0x52145e
leaq 0x4de30e(%rip), %r8     # 0x521471
movl $0x2c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x43177
movl 0x44(%rsp), %edi
subl 0x34(%rsp), %edi
movq 0x38(%rsp), %rsi
movslq 0x34(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1746b0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x139470
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x1f6b70
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x431f9
movq 0x5f8dd8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d2e41(%rip), %rsi    # 0x516013
leaq 0x4de2b0(%rip), %rdx    # 0x521489
leaq 0x4de27e(%rip), %rcx    # 0x52145e
leaq 0x4de28a(%rip), %r8     # 0x521471
movl $0x33, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x431fb
cmpl $0x0, 0xc(%rsp)
jne 0x43215
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1b1f90
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1b1cb0
movq 0x10(%rsp), %rdi
callq 0x1b1cb0
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_magicmatch.c
// Function: gt_magicmatch_arguments_delete
static void gt_magicmatch_arguments_delete(void *tool_arguments)
{
  MagicMatchArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_array_delete(arguments->seqfiles);
  gt_free(arguments);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x432cd
jmp 0x432f0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rdi
leaq 0x4de1b2(%rip), %rsi    # 0x521498
movl $0x2b, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x43353
movq 0x5f8c7e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d2ce7(%rip), %rsi    # 0x516013
leaq 0x53782c(%rip), %rdx    # 0x57ab5f
leaq 0x4de178(%rip), %rcx    # 0x5214b2
leaq 0x4de157(%rip), %r8     # 0x521498
movl $0x33, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x43355
leaq 0x4de176(%rip), %rdi    # 0x5214d2
leaq 0x4de196(%rip), %rsi    # 0x5214f9
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdx
leaq 0x4eb144(%rip), %rdi    # 0x52e4c0
leaq 0x4de1bc(%rip), %rsi    # 0x52153f
callq 0xf6b00
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf6ca0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x8, %rdx
leaq 0x554a9d(%rip), %rdi    # 0x597e53
leaq 0x4de1b3(%rip), %rsi    # 0x521570
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xf6ca0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
leaq 0x13e8f2(%rip), %rsi    # 0x181ce0
xorl %eax, %eax
movl %eax, %edx
callq 0xf1770
movq 0x10(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0xf2a40
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x4348d
movq 0x30(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x43455
jmp 0x4348d
movq 0x5f8b44(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d2bad(%rip), %rsi    # 0x516013
leaq 0x4d2d52(%rip), %rdx    # 0x5161bf
leaq 0x4de121(%rip), %rcx    # 0x521595
leaq 0x4de01d(%rip), %r8     # 0x521498
movl $0x5f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4348f
jmp 0x43491
cmpq $0x0, 0x28(%rsp)
jne 0x434d1
movq 0x5f8b00(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d2b69(%rip), %rsi    # 0x516013
leaq 0x5376ae(%rip), %rdx    # 0x57ab5f
leaq 0x4de0dd(%rip), %rcx    # 0x521595
leaq 0x4ddfd9(%rip), %r8     # 0x521498
movl $0x60, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x434d3
movq 0x28(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x4358d
movq $0x0, 0x18(%rsp)
xorl %eax, %eax
cmpl $0x0, 0x14(%rsp)
movb %al, 0x13(%rsp)
jne 0x43521
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x11fcc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
setb %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x4352b
jmp 0x4358b
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x11f8c0
movq %rax, %rdi
movq 0x30(%rsp), %rsi
callq 0x84600
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
jne 0x4355d
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
cmpl $0x0, 0x14(%rsp)
jne 0x4356e
movq 0x20(%rsp), %rdi
callq 0x435a0
movq 0x20(%rsp), %rdi
callq 0x84960
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x434eb
jmp 0x4358d
movl 0x14(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_magicmatch.c
// Function: translate_sequence_file
static void translate_sequence_file(GtBioseq *bs)
{
  GtUword i;
  gt_assert(bs);
  for (i = 0; i < gt_bioseq_number_of_sequences(bs); i++) {
    printf("%s\t%s\n", gt_bioseq_get_md5_fingerprint(bs, i),
                       gt_bioseq_get_description(bs, i));
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x435e9
movq 0x5f89e8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d2a51(%rip), %rsi    # 0x516013
leaq 0x52647c(%rip), %rdx    # 0x569a45
leaq 0x4ddfda(%rip), %rcx    # 0x5215aa
leaq 0x4ddec1(%rip), %r8     # 0x521498
movl $0x4f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x435eb
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x85910
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x4365e
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x85800
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x84ea0
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x51310c(%rip), %rdi    # 0x556753
movb $0x0, %al
callq 0x19070
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x435f4
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x30, %esi
leaq 0x4ddf10(%rip), %rdx    # 0x5215c2
movl $0x2e, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4372d
jmp 0x4377a
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4dde52(%rip), %rsi    # 0x5215c2
movl $0x3e, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x44e0d
jmp 0x44e4d
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11fd20
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11f560
movq 0x8(%rsp), %rdi
leaq 0x4dcc68(%rip), %rsi    # 0x521aab
movl $0x5d, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movl $0x1, %edi
movl $0x88, %esi
leaq 0x4dbecd(%rip), %rdx    # 0x521aab
movl $0x41, %ecx
callq 0xe83c0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
callq 0x11f5c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movb 0x17(%rsp), %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x44(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_matstat.c
// Function: dotestsequence
static bool dotestsequence(const Gfmsubcallinfo *gfmsubcallinfo)
{
  if (gfmsubcallinfo->indextype == Packedindextype &&
      gfmsubcallinfo->verifywitnesspos &&
      gfmsubcallinfo->doms)
  {
    return true;
  }
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x2, 0x40(%rax)
jne 0x45c8d
movq -0x10(%rsp), %rax
testb $0x1, 0x24(%rax)
je 0x45c8d
movq -0x10(%rsp), %rax
testb $0x1, 0x44(%rax)
je 0x45c8d
movb $0x1, -0x1(%rsp)
jmp 0x45c92
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movl $0x1, %edi
movl $0x20, %esi
leaq 0x4dc0d2(%rip), %rdx    # 0x521db4
movl $0x26, %ecx
callq 0xe83c0
movq %rax, (%rsp)
callq 0x1d43b0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0xf7d20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x45d3d
jmp 0x45d7d
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1d4420
movq 0x8(%rsp), %rdi
leaq 0x4dc041(%rip), %rsi    # 0x521db4
movl $0x33, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x45de3
movq 0x5f61ee(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d0257(%rip), %rsi    # 0x516013
leaq 0x534d9c(%rip), %rdx    # 0x57ab5f
leaq 0x4dc003(%rip), %rcx    # 0x521dcd
leaq 0x4dbfe3(%rip), %r8     # 0x521db4
movl $0x3b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x45de5
leaq 0x4d5756(%rip), %rdi    # 0x51b542
leaq 0x4dbff9(%rip), %rsi    # 0x521dec
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x1d4480
movq 0x18(%rsp), %rdi
callq 0xf5f90
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x18, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x460bd
jmp 0x460ee
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x4dbd72(%rip), %rsi    # 0x521e56
movl $0x30, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x46153
movq 0x5f5e7e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cfee7(%rip), %rsi    # 0x516013
leaq 0x534a2c(%rip), %rdx    # 0x57ab5f
leaq 0x4dbd31(%rip), %rcx    # 0x521e6b
leaq 0x4dbd15(%rip), %r8     # 0x521e56
movl $0x38, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x46155
leaq 0x4d53e6(%rip), %rdi    # 0x51b542
leaq 0x4dbd23(%rip), %rsi    # 0x521e86
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdx
addq $0x10, %rdx
leaq 0x56f75e(%rip), %rdi    # 0x5b58db
leaq 0x4d8a56(%rip), %rsi    # 0x51ebda
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rdx
addq $0x11, %rdx
leaq 0x50bf13(%rip), %rdi    # 0x5520c2
leaq 0x4d89f7(%rip), %rsi    # 0x51ebad
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq $0x8, %rdx
callq 0xf7d50
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/tools/gt_mergeesa.c
// Function: parse_options
static GtOPrval parse_options(GtStr *indexname,GtStrArray *indexnametab,
                              int *parsed_args, int argc,
                              const char **argv, GtError *err)
{
  GtOptionParser *op;
  GtOPrval oprval;
  GtOption *option;

  gt_error_check(err);
  op = gt_option_parser_new("storeindex <mkvindex1> <mkvindex2> ...",
                         "Merge indexes into one index.");
  gt_option_parser_set_mail_address(op,"<kurtz@zbh.uni-hamburg.de>");
  option = gt_option_new_filename_array("ii",
                                    "specify input index files (mandatory)",
                                    indexnametab);
  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  option = gt_option_new_string("indexname",
                             "specify index to be created",
                             indexname, NULL);

  gt_option_is_mandatory(option);
  gt_option_parser_add_option(op, option);

  oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
                                  err);
  gt_option_parser_delete(op);
  return oprval;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x466c1
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x46689
jmp 0x466c1
movq 0x5f5910(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cf979(%rip), %rsi    # 0x516013
leaq 0x4cfb1e(%rip), %rdx    # 0x5161bf
leaq 0x54e7ea(%rip), %rcx    # 0x594e92
leaq 0x4db82b(%rip), %r8     # 0x521eda
movl $0x21, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x466c3
leaq 0x4db845(%rip), %rdi    # 0x521f0f
leaq 0x4db865(%rip), %rsi    # 0x521f36
callq 0xf1420
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x4d0bfd(%rip), %rsi    # 0x5172e4
callq 0xf1a10
movq 0x38(%rsp), %rdx
leaq 0x53fbd5(%rip), %rdi    # 0x5862cd
leaq 0x4db855(%rip), %rsi    # 0x521f54
callq 0xf6b00
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0xf6ca0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf1600
movq 0x40(%rsp), %rdx
leaq 0x4f06b4(%rip), %rdi    # 0x536ddf
leaq 0x4db848(%rip), %rsi    # 0x521f7a
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0xf6ca0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r9
leaq 0xdffbb(%rip), %r8      # 0x126730
callq 0xf2ab0
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0xf5cf0
movl 0xc(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x4682d
jmp 0x4685e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0xde430
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xf8210
movq 0x8(%rsp), %rdi
leaq 0x4db742(%rip), %rsi    # 0x521f96
movl $0x2b, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x468c3
movq 0x5f570e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cf777(%rip), %rsi    # 0x516013
leaq 0x5342bc(%rip), %rdx    # 0x57ab5f
leaq 0x4db705(%rip), %rcx    # 0x521faf
leaq 0x4db6e5(%rip), %r8     # 0x521f96
movl $0x33, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x468c5
leaq 0x4d4c76(%rip), %rdi    # 0x51b542
leaq 0x4db6fb(%rip), %rsi    # 0x521fce
callq 0xf1420
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq $0x8, %rdx
callq 0xf7d50
movq (%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x46975
movq 0x30(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x4693d
jmp 0x46975
movq 0x5f565c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cf6c5(%rip), %rsi    # 0x516013
leaq 0x4cf86a(%rip), %rdx    # 0x5161bf
leaq 0x4db6c3(%rip), %rcx    # 0x52201f
leaq 0x4db633(%rip), %r8     # 0x521f96
movl $0x49, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x46977
jmp 0x46979
cmpq $0x0, 0x28(%rsp)
jne 0x469b9
movq 0x5f5618(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4cf681(%rip), %rsi    # 0x516013
leaq 0x5341c6(%rip), %rdx    # 0x57ab5f
leaq 0x4db67f(%rip), %rcx    # 0x52201f
leaq 0x4db5ef(%rip), %r8     # 0x521f96
movl $0x4a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x469bb
movl 0x54(%rsp), %edi
subl 0x44(%rsp), %edi
movq 0x48(%rsp), %rsi
movslq 0x44(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1746b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1ae160
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x176d50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1b1f90
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1b1cb0
movq 0x18(%rsp), %rdi
callq 0x1b1cb0
movq 0x20(%rsp), %rdi
callq 0x1b1cb0
movl 0xc(%rsp), %eax
addq $0x58, %rsp
retq
nop