LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_extractfeat.c
// Function: gt_extractfeat_arguments_delete
static void gt_extractfeat_arguments_delete(void *tool_arguments)
{
  GtExtractFeatArguments *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_str_delete(arguments->type);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x289c4
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x8da06
movq 0x28(%rbx), %rdi
callq 0x9ba24
movq 0x18(%rbx), %rdi
callq 0x116765
movq 0x10(%rbx), %rdi
callq 0xae103
leaq 0x2c38c0(%rip), %rsi    # 0x2ec278
pushq $0x40
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_extractfeat.c
// Function: gt_extractfeat_comment_func
static int gt_extractfeat_comment_func(const char *progname,
                                       void *data, GtError *err)
{
  GtStrArray *descs = gt_trans_table_get_scheme_descriptions();
  GtUword i = 0;
  printf("\nGenetic code numbers for option '-gcode':\n\n");
  for (i = 0; i < gt_str_array_size(descs); i++) {
    printf("%s\n", gt_str_array_get(descs, i));
  }
  gt_str_array_delete(descs);
  return gt_gtdata_show_help(progname, data,err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xb11bc
movq %rax, %r12
leaq 0x2c372d(%rip), %rdi    # 0x2ec4aa
callq 0x17b60
xorl %r13d, %r13d
movq %r12, %rdi
callq 0xae61c
cmpq %rax, %r13
jae 0x28daa
movq %r12, %rdi
movq %r13, %rsi
callq 0xae386
movq %rax, %rdi
callq 0x17b60
incq %r13
jmp 0x28d85
movq %r12, %rdi
callq 0xae662
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe74ec
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_extractseq.c
// Function: gt_extractseq_arguments_new
static void* gt_extractseq_arguments_new(void)
{
  ExtractSeqArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->pattern = gt_str_new();
  arguments->fastakeyfile = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c36da(%rip), %rdx    # 0x2ec4d6
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
pushq $0x2d
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0x9b6b4
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_extractseq.c
// Function: gt_extractseq_arguments_delete
static void gt_extractseq_arguments_delete(void *tool_arguments)
{
  ExtractSeqArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->fastakeyfile);
  gt_str_delete(arguments->pattern);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x28e6b
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x8da06
movq 0x28(%rbx), %rdi
callq 0x9ba24
movq 0x8(%rbx), %rdi
callq 0xae103
movq (%rbx), %rdi
callq 0xae103
leaq 0x2c3677(%rip), %rsi    # 0x2ec4d6
pushq $0x3c
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_extractseq.c
// Function: gt_extractseq_arguments_check
static int gt_extractseq_arguments_check(GT_UNUSED int argc,
                                         void *tool_arguments, GtError *err)
{
  ExtractSeqArguments *arguments = tool_arguments;
  gt_error_check(err);
  gt_assert(arguments);
  if (arguments->frompos > arguments->topos) {
    gt_error_set(err,
              "argument to option '-%s' must be <= argument to option '-%s'",
              FROMPOS_OPTION_STR, TOPOS_OPTION_STR);
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0x29019
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x29082
testq %r14, %r14
je 0x29054
movq 0x10(%r14), %rcx
xorl %eax, %eax
cmpq 0x18(%r14), %rcx
jbe 0x2904c
leaq 0x2c3686(%rip), %rsi    # 0x2ec6b7
leaq 0x2f08e2(%rip), %rdx    # 0x31991a
leaq 0x2d57ed(%rip), %rcx    # 0x2fe82c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40ef0d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bbfae(%rip), %rsi    # 0x2e5013
leaq 0x31f5e7(%rip), %rdx    # 0x348653
leaq 0x2c3626(%rip), %rcx    # 0x2ec699
leaq 0x2c345c(%rip), %r8     # 0x2ec4d6
movl $0x83, %r9d
jmp 0x290ae
movq 0x40eedf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bbf80(%rip), %rsi    # 0x2e5013
leaq 0x2bc125(%rip), %rdx    # 0x2e51bf
leaq 0x2c35f8(%rip), %rcx    # 0x2ec699
leaq 0x2c342e(%rip), %r8     # 0x2ec4d6
movl $0x82, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_extracttarget.c
// Function: gt_extracttarget_option_parser_new
static GtOptionParser* gt_extracttarget_option_parser_new(void *tool_arguments)
{
  ExtractTargetArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *o;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] -seqfile sequence_file GFF3_file",
                         "Extract target sequences given in GFF3_file from "
                         "sequence_file.");

  /* -seqfile */
  o = gt_option_new_filename_array("seqfiles",
                                   "set the sequence file from which "
                                   "to extract the features",
                                   arguments->seqfiles);
  gt_option_is_mandatory(o);
  gt_option_parser_add_option(op, o);

  gt_option_parser_set_min_max_args(op, 1, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29890
movq %rdi, %rbx
leaq 0x2c2ff3(%rip), %rdi    # 0x2ec830
leaq 0x2c301a(%rip), %rsi    # 0x2ec85e
callq 0x97df5
movq %rax, %r14
movq (%rbx), %rdx
leaq 0x2c30b7(%rip), %rdi    # 0x2ec90d
leaq 0x2c3041(%rip), %rsi    # 0x2ec89e
callq 0x9ad7e
movq %rax, %rbx
movq %rax, %rdi
callq 0x9ae37
movq %r14, %rdi
movq %rbx, %rsi
callq 0x97f31
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %edx, %esi
callq 0x98c6b
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40e6d1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bb772(%rip), %rsi    # 0x2e5013
leaq 0x31edab(%rip), %rdx    # 0x348653
leaq 0x2c2f5e(%rip), %rcx    # 0x2ec80d
leaq 0x2c2f3a(%rip), %r8     # 0x2ec7f0
pushq $0x3a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_extracttarget.c
// Function: show_target
static bool show_target(GT_UNUSED GtUword pos, void *data)
{
  TargetInfo *ti = data;
  char *seq;
  gt_assert(ti);
  seq = gt_bioseq_get_sequence(ti->bioseq, ti->seqnum);
  gt_fasta_show_entry(gt_bioseq_get_description(ti->bioseq, ti->seqnum),
                      seq,
                      gt_bioseq_get_sequence_length(ti->bioseq, ti->seqnum), 0,
                      NULL);
  gt_free(seq);
  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x29d6d
movq %rsi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x5b1f9
movq %rax, %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x5b338
movq %rax, %r15
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x5b2f1
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8c0bc
leaq 0x2c2a96(%rip), %rsi    # 0x2ec7f0
pushq $0x5d
popq %rdx
movq %r14, %rdi
callq 0x936f9
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movq 0x40e1f4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bb295(%rip), %rsi    # 0x2e5013
leaq 0x2d91e8(%rip), %rdx    # 0x302f6d
leaq 0x2c2bad(%rip), %rcx    # 0x2ec939
leaq 0x2c2a5d(%rip), %r8     # 0x2ec7f0
pushq $0x57
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_fastq_sample.c
// Function: gt_fastq_sample_option_parser_new
static GtOptionParser* gt_fastq_sample_option_parser_new(void *tool_arguments)
{
  GtFastqSampleArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *optionlength;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] -length <n> <fastq_file> "
                            "[<fastq_file>...]",
                            "Print samples by random choice from given FASTQ "\
                            "files using at least n sequence-chars.\n"\
                            "Output is fastq/fasta format depending on "\
                            "whether qualities are available.");

  /* -length */
  optionlength = gt_option_new_uword("length",
                                     "minimum number of chars to be chosen",
                                     &arguments->length,
                                     GT_UNDEF_UWORD);
  gt_option_is_mandatory(optionlength);
  gt_option_parser_add_option(op, optionlength);

  gt_option_parser_set_min_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29e5d
movq %rdi, %rbx
leaq 0x2c2b7a(%rip), %rdi    # 0x2ec983
leaq 0x2c2bab(%rip), %rsi    # 0x2ec9bb
callq 0x97df5
movq %rax, %r14
leaq 0x337a1e(%rip), %rdi    # 0x36183d
leaq 0x2c2c37(%rip), %rsi    # 0x2eca5d
pushq $-0x1
popq %rcx
movq %rbx, %rdx
callq 0x9a9e6
movq %rax, %rbx
movq %rax, %rdi
callq 0x9ae37
movq %r14, %rdi
movq %rbx, %rsi
callq 0x97f31
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x98be7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40e104(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bb1a5(%rip), %rsi    # 0x2e5013
leaq 0x31e7de(%rip), %rdx    # 0x348653
leaq 0x2c2ae5(%rip), %rcx    # 0x2ec961
leaq 0x2c2ac2(%rip), %r8     # 0x2ec945
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_fastq_sample.c
// Function: gt_fastq_sample_arguments_check
static int gt_fastq_sample_arguments_check(GT_UNUSED int rest_argc,
                                           void *tool_arguments,
                                           GtError *err)
{
  GtFastqSampleArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  if (arguments->length < 1) {
    gt_error_set(err, "length must be a positive integer");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdx, %rdx
je 0x29eae
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x29f01
testq %r14, %r14
je 0x29ed7
xorl %eax, %eax
cmpq $0x0, (%r14)
jne 0x29ecf
leaq 0x2c2be0(%rip), %rsi    # 0x2ecaa2
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40e08a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bb12b(%rip), %rsi    # 0x2e5013
leaq 0x31e764(%rip), %rdx    # 0x348653
leaq 0x2c2b8c(%rip), %rcx    # 0x2eca82
leaq 0x2c2a48(%rip), %r8     # 0x2ec945
pushq $0x57
jmp 0x29f29
movq 0x40e060(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2bb101(%rip), %rsi    # 0x2e5013
leaq 0x2bb2a6(%rip), %rdx    # 0x2e51bf
leaq 0x2c2b62(%rip), %rcx    # 0x2eca82
leaq 0x2c2a1e(%rip), %r8     # 0x2ec945
pushq $0x56
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_featureindex.c
// Function: gt_featureindex_arguments_new
static void* gt_featureindex_arguments_new(void)
{
  GtFeatureindexArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->seqid = gt_str_new();
  arguments->backend = gt_str_new();
  arguments->filename = gt_str_new();
  arguments->host = gt_str_new();
  arguments->user = gt_str_new();
  arguments->database = gt_str_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c282f(%rip), %rdx    # 0x2ecb6b
pushq $0x1
popq %rdi
pushq $0x58
popq %rsi
pushq $0x3d
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
callq 0xacb84
movq %rax, 0x28(%rbx)
callq 0xacb84
movq %rax, 0x30(%rbx)
callq 0xacb84
movq %rax, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_featureindex.c
// Function: gt_featureindex_arguments_delete
static void gt_featureindex_arguments_delete(void *tool_arguments)
{
  GtFeatureindexArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->seqid);
  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_option_delete(arguments->rngopt);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x2a3ec
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0x20(%rbx), %rdi
callq 0xae103
movq 0x28(%rbx), %rdi
callq 0xae103
movq 0x30(%rbx), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0xae103
movq 0x40(%rbx), %rdi
callq 0xae103
movq 0x50(%rbx), %rdi
callq 0x9a8ea
leaq 0x2c278b(%rip), %rsi    # 0x2ecb6b
pushq $0x53
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_featureindex.c
// Function: gt_featureindex_arguments_check
static int gt_featureindex_arguments_check(GT_UNUSED int rest_argc,
                                           GT_UNUSED void *tool_arguments,
                                           GT_UNUSED GtError *err)
{
  GT_UNUSED GtFeatureindexArguments *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 0x2a5b4
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2a5eb
testq %rbx, %rbx
je 0x2a5bd
xorl %eax, %eax
popq %rbx
retq
movq 0x40d9a4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2baa45(%rip), %rsi    # 0x2e5013
leaq 0x31e07e(%rip), %rdx    # 0x348653
leaq 0x2c273e(%rip), %rcx    # 0x2ecd1a
leaq 0x2c2588(%rip), %r8     # 0x2ecb6b
movl $0xc0, %r9d
jmp 0x2a617
movq 0x40d976(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2baa17(%rip), %rsi    # 0x2e5013
leaq 0x2babbc(%rip), %rdx    # 0x2e51bf
leaq 0x2c2710(%rip), %rcx    # 0x2ecd1a
leaq 0x2c255a(%rip), %r8     # 0x2ecb6b
movl $0xbf, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_fingerprint.c
// Function: gt_fingerprint_arguments_new
static void* gt_fingerprint_arguments_new(void)
{
  FingerprintArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->checklist = gt_str_new();
  arguments->extract = gt_str_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c2319(%rip), %rdx    # 0x2ecd70
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
pushq $0x2e
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0x9b6b4
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_fingerprint.c
// Function: gt_fingerprint_arguments_delete
static void gt_fingerprint_arguments_delete(void *tool_arguments)
{
  FingerprintArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_output_file_info_delete(arguments->ofi);
  gt_str_delete(arguments->extract);
  gt_str_delete(arguments->checklist);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x2aac8
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x8da06
movq 0x20(%rbx), %rdi
callq 0x9ba24
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
leaq 0x2c22b4(%rip), %rsi    # 0x2ecd70
pushq $0x3d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_fingerprint.c
// Function: proc_superfluous_sequence
static void proc_superfluous_sequence(const char *string,
                                      GT_UNUSED GtUword occurrences,
                                      GT_UNUSED double probability, void *data)
{
  bool *comparisons_failed = data;
  gt_assert(string && occurrences && comparisons_failed);
  printf("%s only in sequence_file(s)\n", string);
  *comparisons_failed = true;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2b60e
testq %rsi, %rsi
je 0x2b60e
movq %rdx, %rbx
testq %rdx, %rdx
je 0x2b60e
movq %rdi, %rax
leaq 0x2c1aca(%rip), %rdi    # 0x2ed0c9
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
movb $0x1, (%rbx)
popq %rbx
retq
movq 0x40c953(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b99f4(%rip), %rsi    # 0x2e5013
leaq 0x2c1a5d(%rip), %rdx    # 0x2ed083
leaq 0x2c1a82(%rip), %rcx    # 0x2ed0af
leaq 0x2c173c(%rip), %r8     # 0x2ecd70
movl $0x88, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_fingerprint.c
// Function: show_duplicate
static void show_duplicate(const char *fingerprint, GtUword occurrences,
                           GT_UNUSED double probability, void *data)
{
  FingerprintInfo *info = data;
  if (occurrences > 1) {
    printf("%s\t"GT_WU"\n", fingerprint, occurrences);
    info->duplicates += occurrences - 1;
  }
  info->num_of_sequences += occurrences;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
cmpq $0x2, %rsi
jb 0x2b676
movq %rdi, %rsi
leaq 0x2c1ac2(%rip), %rdi    # 0x2ed122
movq %r14, %rdx
xorl %eax, %eax
callq 0x17070
movq (%rbx), %rax
addq %r14, %rax
decq %rax
movq %rax, (%rbx)
addq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gdiffcalc.c
// Function: gt_gdiffcalc_arguments_new
static void* gt_gdiffcalc_arguments_new(void)
{
  GtGenomediffArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->indexname = gt_str_new();
  arguments->unitfile = gt_str_new();
  arguments->indextype = gt_str_new();
  arguments->filenames = gt_str_array_new();
  arguments->with_esa = arguments->with_pck = false;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c1b14(%rip), %rdx    # 0x2ed1c8
pushq $0x1
popq %rdi
pushq $0x70
popq %rsi
pushq $0x2e
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x50(%rbx)
callq 0xacb84
movq %rax, 0x60(%rbx)
callq 0xacb84
movq %rax, 0x58(%rbx)
callq 0xae154
movq %rax, 0x68(%rbx)
andw $0x0, 0x2(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gdiffcalc.c
// Function: gt_gdiffcalc_arguments_delete
static void gt_gdiffcalc_arguments_delete(void *tool_arguments)
{
  GtGenomediffArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->indexname);
  gt_str_delete(arguments->unitfile);
  gt_str_delete(arguments->indextype);
  gt_str_array_delete(arguments->filenames);
  gt_option_delete(arguments->ref_unitfile);
  gt_encseq_options_delete(arguments->loadopts);
  gt_index_options_delete(arguments->idxopts);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x2b74e
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
callq 0xae103
movq 0x60(%rbx), %rdi
callq 0xae103
movq 0x58(%rbx), %rdi
callq 0xae103
movq 0x68(%rbx), %rdi
callq 0xae662
movq 0x48(%rbx), %rdi
callq 0x9a8ea
movq 0x38(%rbx), %rdi
callq 0x89b38
movq 0x40(%rbx), %rdi
callq 0x164081
leaq 0x2c1a86(%rip), %rsi    # 0x2ed1c8
pushq $0x42
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gdiffcalc.c
// Function: gt_gdiffcalc_arguments_check
static int gt_gdiffcalc_arguments_check(GT_UNUSED int rest_argc,
                                       void *tool_arguments,
                                       GT_UNUSED GtError *err)
{
  GtGenomediffArguments *arguments = tool_arguments;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(arguments);

  gt_assert(rest_argc == 1);
  if (!had_err)
    arguments->with_units = gt_option_is_set(arguments->ref_unitfile);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
testq %rdx, %rdx
je 0x2b9aa
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2ba25
testq %rbx, %rbx
je 0x2b9c9
cmpl $0x1, %ebp
jne 0x2b9f7
movq 0x48(%rbx), %rdi
callq 0x9b4cb
movb %al, 0x4(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x40c598(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b9639(%rip), %rsi    # 0x2e5013
leaq 0x31cc72(%rip), %rdx    # 0x348653
leaq 0x2c1a38(%rip), %rcx    # 0x2ed420
leaq 0x2c17d9(%rip), %r8     # 0x2ed1c8
movl $0xad, %r9d
jmp 0x2ba51
movq 0x40c56a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b960b(%rip), %rsi    # 0x2e5013
leaq 0x2c1a2e(%rip), %rdx    # 0x2ed43d
leaq 0x2c1a0a(%rip), %rcx    # 0x2ed420
leaq 0x2c17ab(%rip), %r8     # 0x2ed1c8
movl $0xaf, %r9d
jmp 0x2ba51
movq 0x40c53c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b95dd(%rip), %rsi    # 0x2e5013
leaq 0x2b9782(%rip), %rdx    # 0x2e51bf
leaq 0x2c19dc(%rip), %rcx    # 0x2ed420
leaq 0x2c177d(%rip), %r8     # 0x2ed1c8
movl $0xac, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_genomediff.c
// Function: gt_genomediff_arguments_new
static void* gt_genomediff_arguments_new(void)
{
  GtGenomediffArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
  arguments->indexname = gt_str_new();
  arguments->unitfile = gt_str_new();
  arguments->indextype = gt_str_new();
  arguments->filenames = gt_str_array_new();
  arguments->with_esa = arguments->with_pck = false;
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c14aa(%rip), %rdx    # 0x2ed566
pushq $0x1
popq %rdi
pushq $0x70
popq %rsi
pushq $0x2c
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x50(%rbx)
callq 0xacb84
movq %rax, 0x60(%rbx)
callq 0xacb84
movq %rax, 0x58(%rbx)
callq 0xae154
movq %rax, 0x68(%rbx)
andw $0x0, 0x2(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gff3.c
// Function: gt_gff3_arguments_new
static void* gt_gff3_arguments_new(void)
{
  GFF3Arguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->newsource = gt_str_new();
  arguments->offsetfile = gt_str_new();
  arguments->tci = gt_typecheck_info_new();
  arguments->xci = gt_xrfcheck_info_new();
  arguments->ofi = gt_output_file_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c0c81(%rip), %rdx    # 0x2ed948
pushq $0x1
popq %rdi
pushq $0x50
popq %rsi
pushq $0x44
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0xacb84
movq %rax, 0x20(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0x12aab4
movq %rax, 0x30(%rbx)
callq 0x12e3f4
movq %rax, 0x38(%rbx)
callq 0x9b6b4
movq %rax, 0x40(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gff3.c
// Function: gt_gff3_arguments_delete
static void gt_gff3_arguments_delete(void *tool_arguments)
{
  GFF3Arguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_file_delete(arguments->outfp);
  gt_str_delete(arguments->newsource);
  gt_output_file_info_delete(arguments->ofi);
  gt_typecheck_info_delete(arguments->tci);
  gt_xrfcheck_info_delete(arguments->xci);
  gt_str_delete(arguments->offsetfile);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x2cd5c
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
callq 0x8da06
movq 0x20(%rbx), %rdi
callq 0xae103
movq 0x40(%rbx), %rdi
callq 0x9ba24
movq 0x30(%rbx), %rdi
callq 0x12aada
movq 0x38(%rbx), %rdi
callq 0x12e41a
movq 0x18(%rbx), %rdi
callq 0xae103
leaq 0x2c0bf8(%rip), %rsi    # 0x2ed948
pushq $0x57
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gff3_to_gtf.c
// Function: gt_gff3_to_gtf_arguments_delete
static void gt_gff3_to_gtf_arguments_delete(void *tool_arguments)
{
  GFF3ToGTFArguments *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 0x2d65e
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x8da06
movq (%rbx), %rdi
callq 0x9ba24
leaq 0x2c0962(%rip), %rsi    # 0x2edfb4
pushq $0x2c
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gff3_to_gtf.c
// Function: gt_gff3_to_gtf_runner
static int gt_gff3_to_gtf_runner(int argc, const char **argv, int parsed_args,
                                 void *tool_arguments, GtError *err)
{
  GFF3ToGTFArguments *arguments = tool_arguments;
  GtNodeStream *gff3_in_stream = NULL, *gtf_out_stream = NULL;
  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 a gtf output stream */
  gtf_out_stream = gt_gtf_out_stream_new(gff3_in_stream, arguments->outfp);

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

  /* free */
  gt_node_stream_delete(gff3_in_stream);
  gt_node_stream_delete(gtf_out_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 0x2d6c0
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2d73a
testq %r14, %r14
je 0x2d710
subl %r12d, %ebp
movslq %r12d, %rax
leaq (%r15,%rax,8), %rsi
movl %ebp, %edi
callq 0xdeebd
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0xe7a00
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102b93
movl %eax, %ebx
movq %r15, %rdi
callq 0x10297b
movq %r14, %rdi
callq 0x10297b
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x40a851(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b78f2(%rip), %rsi    # 0x2e5013
leaq 0x31af2b(%rip), %rdx    # 0x348653
leaq 0x2c08cc(%rip), %rcx    # 0x2edffb
leaq 0x2c087e(%rip), %r8     # 0x2edfb4
pushq $0x41
jmp 0x2d762
movq 0x40a827(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b78c8(%rip), %rsi    # 0x2e5013
leaq 0x2b7a6d(%rip), %rdx    # 0x2e51bf
leaq 0x2c08a2(%rip), %rcx    # 0x2edffb
leaq 0x2c0854(%rip), %r8     # 0x2edfb4
pushq $0x40
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gff3validator.c
// Function: gt_gff3validator_arguments_new
static void* gt_gff3validator_arguments_new(void)
{
  GFF3ValidatorArguments *arguments = gt_calloc(1, sizeof *arguments);
  arguments->tci = gt_typecheck_info_new();
  arguments->xci = gt_xrfcheck_info_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c0876(%rip), %rdx    # 0x2ee011
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
pushq $0x23
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x12aab4
movq %rax, (%rbx)
callq 0x12e3f4
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gff3validator.c
// Function: gt_gff3validator_arguments_delete
static void gt_gff3validator_arguments_delete(void *tool_arguments)
{
  GFF3ValidatorArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_typecheck_info_delete(arguments->tci);
  gt_xrfcheck_info_delete(arguments->xci);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x2d7ef
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x12aada
movq 0x8(%rbx), %rdi
callq 0x12e41a
leaq 0x2c082e(%rip), %rsi    # 0x2ee011
pushq $0x2f
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gff3validator.c
// Function: gt_gff3validator_option_parser_new
static GtOptionParser* gt_gff3validator_option_parser_new(void *tool_arguments)
{
  GFF3ValidatorArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[option ...] [GFF3_file ...]",
                         "Strictly validate given GFF3 files.");

  /* typecheck options */
  gt_typecheck_info_register_options(arguments->tci, op);

  /* xrfcheck options */
  gt_xrfcheck_info_register_options(arguments->xci, op);

  /* -strict */
  option = gt_option_new_bool("strict", "be very strict during GFF3 parsing "
                              "(stricter than the specification requires)",
                              &arguments->strict, false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2d866
movq %rdi, %r14
leaq 0x2bccf6(%rip), %rdi    # 0x2ea4f9
leaq 0x2c0847(%rip), %rsi    # 0x2ee051
callq 0x97df5
movq %rax, %rbx
movq (%r14), %rdi
movq %rax, %rsi
callq 0x12ac0d
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x12e448
addq $0x10, %r14
leaq 0x2f26d1(%rip), %rdi    # 0x31ff05
leaq 0x2c0284(%rip), %rsi    # 0x2edabf
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r14
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x97f31
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40a6fb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b779c(%rip), %rsi    # 0x2e5013
leaq 0x31add5(%rip), %rdx    # 0x348653
leaq 0x2c07a9(%rip), %rcx    # 0x2ee02e
leaq 0x2c0785(%rip), %r8     # 0x2ee011
pushq $0x37
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gtf_to_gff3.c
// Function: gt_gtf_to_gff3_arguments_delete
static void gt_gtf_to_gff3_arguments_delete(void *tool_arguments)
{
  GTFToGFF3Arguments *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 0x2da9c
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x8da06
movq 0x8(%rbx), %rdi
callq 0x9ba24
leaq 0x2c0611(%rip), %rsi    # 0x2ee0a1
pushq $0x2f
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gtf_to_gff3.c
// Function: gt_gtf_to_gff3_option_parser_new
static GtOptionParser* gt_gtf_to_gff3_option_parser_new(void *tool_arguments)
{
  GTFToGFF3Arguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[GTF_file]",
                            "Parse GTF2.2 file and convert it to GFF3.");

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

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

  gt_option_parser_set_max_args(op, 1);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2db0b
movq %rdi, %rbx
leaq 0x2c062d(%rip), %rdi    # 0x2ee0dd
leaq 0x2c0631(%rip), %rsi    # 0x2ee0e8
callq 0x97df5
movq %rax, %r14
leaq 0x2f2405(%rip), %rdi    # 0x31fecb
leaq 0x2c0645(%rip), %rsi    # 0x2ee112
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %r14, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x8(%rbx), %rdi
addq $0x10, %rbx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x9b6d7
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x98c29
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40a456(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b74f7(%rip), %rsi    # 0x2e5013
leaq 0x31ab30(%rip), %rdx    # 0x348653
leaq 0x2c0592(%rip), %rcx    # 0x2ee0bc
leaq 0x2c0570(%rip), %r8     # 0x2ee0a1
pushq $0x37
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_gtf_to_gff3.c
// Function: gt_gtf_to_gff3_runner
static int gt_gtf_to_gff3_runner(GT_UNUSED int argc, const char **argv,
                                 int parsed_args, void *tool_arguments,
                                 GtError *err)
{
  GTFToGFF3Arguments *arguments = tool_arguments;
  GtNodeStream *gtf_in_stream = NULL, *gff3_out_stream = NULL;
  int had_err;

  gt_error_check(err);
  gt_assert(arguments);

  /* create a GTF input stream */
  gtf_in_stream = gt_gtf_in_stream_new(argv[parsed_args]);
  if (arguments->tidy)
    gt_gtf_in_stream_enable_tidy_mode(gtf_in_stream);

  /* create a GFF3 output stream */
  gff3_out_stream = gt_gff3_out_stream_new(gtf_in_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(gtf_in_stream);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
testq %r8, %r8
je 0x2db68
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2dbed
testq %r14, %r14
je 0x2dbc3
movslq %ebp, %rax
movq (%r15,%rax,8), %rdi
callq 0xe7977
movq %rax, %r15
cmpb $0x1, (%r14)
jne 0x2db8a
movq %r15, %rdi
callq 0xe79e4
movq 0x10(%r14), %rsi
movq %r15, %rdi
callq 0xe07df
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102b93
movl %eax, %ebx
movq %r14, %rdi
callq 0x10297b
movq %r15, %rdi
callq 0x10297b
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x40a39e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b743f(%rip), %rsi    # 0x2e5013
leaq 0x31aa78(%rip), %rdx    # 0x348653
leaq 0x2c055b(%rip), %rcx    # 0x2ee13d
leaq 0x2c04b8(%rip), %r8     # 0x2ee0a1
pushq $0x52
jmp 0x2dc15
movq 0x40a374(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b7415(%rip), %rsi    # 0x2e5013
leaq 0x2b75ba(%rip), %rdx    # 0x2e51bf
leaq 0x2c0531(%rip), %rcx    # 0x2ee13d
leaq 0x2c048e(%rip), %r8     # 0x2ee0a1
pushq $0x51
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_guessprot.c
// Function: gt_guessprot
int gt_guessprot(int argc, const char **argv, GtError *err)
{
  int i, parsed_args, retval;
  GtStrArray *filenametab;

  gt_error_check(err);

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

  filenametab = gt_str_array_new();
  for (i=parsed_args; i < argc; i++)
  {
    gt_str_array_add_cstr(filenametab,argv[i]);
  }
  retval = gt_files_guess_if_protein_sequences(filenametab,err);
  gt_str_array_delete(filenametab);
  if (retval < 0)
  {
    return -1;
  }
  if (retval == 1)
  {
    /*@ignore@*/
    exit(EXIT_FAILURE); /* guess it is a protein sequence */
    /*@end@*/

  } else
  {
    return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
testq %rdx, %rdx
je 0x2dc5c
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2dd12
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x2dd3c
leaq 0x3028e7(%rip), %rdi    # 0x33054a
leaq 0x2c050f(%rip), %rsi    # 0x2ee179
callq 0x97df5
movq %rax, %r15
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x98be7
leaq 0x84fcc(%rip), %r8      # 0xb2c50
leaq 0x4(%rsp), %rsi
movq %r15, %rdi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0x98cb0
movl %eax, %r12d
movq %r15, %rdi
callq 0x9a844
pushq $-0x1
popq %r15
cmpl $0x1, %r12d
je 0x2dd00
cmpl $0x2, %r12d
jne 0x2dcb9
xorl %r15d, %r15d
jmp 0x2dd00
callq 0xae154
movq %rax, %r12
movslq 0x4(%rsp), %r13
movslq %ebp, %rbp
cmpq %rbp, %r13
jge 0x2dcdf
movq (%r14,%r13,8), %rsi
movq %r12, %rdi
callq 0xae22f
incq %r13
jmp 0x2dcc9
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8e27f
movl %eax, %ebx
movq %r12, %rdi
callq 0xae662
testl %ebx, %ebx
js 0x2dd00
xorl %r15d, %r15d
cmpl $0x1, %ebx
je 0x2dd72
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x40a24f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b72f0(%rip), %rsi    # 0x2e5013
leaq 0x2b7495(%rip), %rdx    # 0x2e51bf
leaq 0x2c0422(%rip), %rcx    # 0x2ee153
leaq 0x2c0428(%rip), %r8     # 0x2ee160
pushq $0x2c
jmp 0x2dd64
movq 0x40a225(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b72c6(%rip), %rsi    # 0x2e5013
leaq 0x2b746b(%rip), %rdx    # 0x2e51bf
leaq 0x334197(%rip), %rcx    # 0x361ef2
leaq 0x2c03fe(%rip), %r8     # 0x2ee160
pushq $0x1d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
pushq $0x1
popq %rdi
callq 0x178f0
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_hop.c
// Function: gt_hop_arguments_check
int gt_hop_arguments_check(GT_UNUSED int rest_argc, void *tool_arguments,
    GtError* err)
{
  GtHopArguments *args = (GtHopArguments*) tool_arguments;
  int had_err = 0;

  if (!args->aggressive &&
      !args->moderate &&
      !args->conservative &&
      !args->expert &&
      !args->state_of_truth)
  {
    gt_error_set(err, "Select correction mode: "
        "-aggressive, -moderate, -conservative or -expert");
    had_err = -1;
  }
  else if (args->aggressive || args->state_of_truth)
  {
    args->hmin = 3UL;
    args->read_hmin = 1UL;
    args->qmax = 120UL;
    args->altmax = (double) 1.00;
    args->cogmin = (double) 0.00;
    args->mapqmin = 0UL;
    args->covmin = 1UL;
    args->clenmax = ULONG_MAX;
    args->allow_multiple = true;
  }
  else if (args->moderate)
  {
    args->hmin = 3UL;
    args->read_hmin = 1UL;
    args->qmax = 120UL;
    args->altmax = (double) 0.99;
    args->cogmin = (double) 0.00;
    args->mapqmin = 10UL;
    args->covmin = 1UL;
    args->clenmax = ULONG_MAX;
    args->allow_multiple = true;
  }
  else if (args->conservative)
  {
    args->hmin = 3UL;
    args->read_hmin = 2UL;
    args->qmax = 120UL;
    args->altmax = (double) 0.80;
    args->cogmin = (double) 0.10;
    args->mapqmin = 21UL;
    args->covmin = 1UL;
    args->clenmax = ULONG_MAX;
    args->allow_multiple = false;
  }

  if (gt_str_length(args->outprefix) == 0)
  {
    gt_error_set(err, "outprefix cannot be an empty string");
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0x0, 0x66(%rsi)
je 0x2ddee
movq $0x3, 0x30(%r14)
pushq $0x1
popq %rax
movq %rax, 0x40(%r14)
movq $0x78, 0x58(%r14)
movsd 0x2b847d(%rip), %xmm0   # 0x2e6228
movups %xmm0, 0x70(%r14)
andq $0x0, 0x50(%r14)
movq %rax, 0x48(%r14)
orq $-0x1, 0x38(%r14)
movb $0x1, 0x65(%r14)
xorl %ebp, %ebp
movq 0x28(%r14), %rdi
callq 0xad289
testq %rax, %rax
jne 0x2dde7
leaq 0x2c0447(%rip), %rsi    # 0x2ee221
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movb 0x67(%r14), %al
testb %al, %al
je 0x2ddff
cmpb $0x1, 0x6a(%r14)
je 0x2dd8c
jmp 0x2de27
cmpb $0x0, 0x68(%r14)
jne 0x2de18
cmpb $0x0, 0x69(%r14)
jne 0x2de18
cmpb $0x0, 0x6a(%r14)
je 0x2dea8
cmpb $0x0, 0x6a(%r14)
jne 0x2dd8c
testb %al, %al
je 0x2de58
movq $0x3, 0x30(%r14)
pushq $0x1
popq %rax
movq %rax, 0x40(%r14)
movq $0x78, 0x58(%r14)
movsd 0x2c037a(%rip), %xmm0   # 0x2ee1c0
movups %xmm0, 0x70(%r14)
movq $0xa, 0x50(%r14)
jmp 0x2ddb5
xorl %ebp, %ebp
cmpb $0x1, 0x68(%r14)
jne 0x2ddc5
movq $0x3, 0x30(%r14)
movq $0x2, 0x40(%r14)
movq $0x78, 0x58(%r14)
movaps 0x2c032c(%rip), %xmm0   # 0x2ee1b0
movups %xmm0, 0x70(%r14)
movq $0x15, 0x50(%r14)
movq $0x1, 0x48(%r14)
orq $-0x1, 0x38(%r14)
movb $0x0, 0x65(%r14)
jmp 0x2ddc5
pushq $-0x1
popq %rbp
leaq 0x2c0326(%rip), %rsi    # 0x2ee1d8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
jmp 0x2ddc5
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_hop.c
// Function: gt_hop_arguments_new
static void* gt_hop_arguments_new(void)
{
  GtHopArguments *arguments = gt_malloc(sizeof (*arguments));
  arguments->encseqinput = gt_str_new();
  arguments->annotation = gt_str_new();
  arguments->atype = gt_str_new();
  arguments->map = gt_str_new();
  arguments->outfilename = gt_str_new();
  arguments->outprefix = gt_str_new();
  arguments->readset = gt_str_array_new();
  return arguments;
}

// Assembly:
pushq %rbx
leaq 0x2c0354(%rip), %rsi    # 0x2ee245
pushq $0x27
popq %rdx
movl $0x88, %edi
callq 0x93160
movq %rax, %rbx
callq 0xacb84
movq %rax, (%rbx)
callq 0xacb84
movq %rax, 0x8(%rbx)
callq 0xacb84
movq %rax, 0x20(%rbx)
callq 0xacb84
movq %rax, 0x10(%rbx)
callq 0xacb84
movq %rax, 0x18(%rbx)
callq 0xacb84
movq %rax, 0x28(%rbx)
callq 0xae154
movq %rax, 0x80(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_hop.c
// Function: gt_hop_arguments_delete
static void gt_hop_arguments_delete(void *tool_arguments)
{
  GtHopArguments *arguments = tool_arguments;
  if (!arguments) return;
  gt_str_delete(arguments->encseqinput);
  gt_str_delete(arguments->annotation);
  gt_str_delete(arguments->atype);
  gt_str_delete(arguments->map);
  gt_str_delete(arguments->outfilename);
  gt_str_delete(arguments->outprefix);
  gt_str_array_delete(arguments->readset);
  gt_free(arguments);
}

// Assembly:
testq %rdi, %rdi
je 0x2dfa4
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xae103
movq 0x8(%rbx), %rdi
callq 0xae103
movq 0x20(%rbx), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae103
movq 0x18(%rbx), %rdi
callq 0xae103
movq 0x28(%rbx), %rdi
callq 0xae103
movq 0x80(%rbx), %rdi
callq 0xae662
leaq 0x2c02ad(%rip), %rsi    # 0x2ee245
pushq $0x3d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_id_to_md5.c
// Function: gt_id_to_md5_arguments_new
static void *gt_id_to_md5_arguments_new(void)
{
  SeqidsToMD5Arguments *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 0x2c01b6(%rip), %rdx    # 0x2ef05d
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x28
popq %rcx
callq 0x9334a
movq %rax, %rbx
callq 0x116724
movq %rax, 0x8(%rbx)
callq 0x9b6b4
movq %rax, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_id_to_md5.c
// Function: gt_id_to_md5_arguments_delete
static void gt_id_to_md5_arguments_delete(void *tool_arguments)
{
  SeqidsToMD5Arguments *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 0x2ef06
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x8da06
movq 0x10(%rbx), %rdi
callq 0x9ba24
movq 0x8(%rbx), %rdi
callq 0x116765
leaq 0x2c0163(%rip), %rsi    # 0x2ef05d
pushq $0x35
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_id_to_md5.c
// Function: gt_id_to_md5_option_parser_new
static GtOptionParser* gt_id_to_md5_option_parser_new(void *tool_arguments)
{
  SeqidsToMD5Arguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option;
  gt_assert(arguments);

  op = gt_option_parser_new("[option ...] [GFF3_file ...]",
                            "Change sequence IDs in given GFF3 files to MD5 "
                            "fingerprints of the corresponding sequences.");

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

  /* -subtargetids */
  option = gt_option_new_bool("subtargetids", "substitute the target IDs with "
                              "MD5 sums", &arguments->substitute_target_ids,
                              true);
  gt_option_parser_add_option(op, option);

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

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

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);

  return op;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2efa0
movq %rdi, %r14
leaq 0x2bb5db(%rip), %rdi    # 0x2ea4f9
leaq 0x2c0170(%rip), %rsi    # 0x2ef095
callq 0x97df5
movq %rax, %rbx
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x116b0e
leaq 0x1(%r14), %rdx
leaq 0x2c01ad(%rip), %rdi    # 0x2ef0f1
leaq 0x2c01b3(%rip), %rsi    # 0x2ef0fe
pushq $0x1
popq %rcx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r14, %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%r14), %rdi
addq $0x18, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x9b6d7
leaq 0xb8561(%rip), %rsi     # 0xe74ec
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98045
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x408fc1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b6062(%rip), %rsi    # 0x2e5013
leaq 0x31969b(%rip), %rdx    # 0x348653
leaq 0x2c00b7(%rip), %rcx    # 0x2ef076
leaq 0x2c0097(%rip), %r8     # 0x2ef05d
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_idxlocali.c
// Function: gt_idxlocali_arguments_delete
static void gt_idxlocali_arguments_delete(void *tool_arguments)
{
  IdxlocaliOptions *arguments = tool_arguments;

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

// Assembly:
testq %rdi, %rdi
je 0x2f1a1
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xae103
movq (%rbx), %rdi
callq 0xae662
movq 0x10(%rbx), %rdi
callq 0x9a8ea
movq 0x18(%rbx), %rdi
callq 0x9a8ea
leaq 0x2bffa5(%rip), %rsi    # 0x2ef13a
pushq $0x2c
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_idxlocali.c
// Function: gt_idxlocali_arguments_check
static int gt_idxlocali_arguments_check(GT_UNUSED int rest_argc,
                                        void *tool_arguments,
                                        GT_UNUSED GtError * err)
{
  IdxlocaliOptions *arguments = tool_arguments;

  if (gt_option_is_set(arguments->refoptionesaindex))
  {
    arguments->withesa = true;
  } else
  {
    gt_assert(gt_option_is_set(arguments->refoptionpckindex));
    arguments->withesa = false;
  }
  return 0;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rsi), %rdi
callq 0x9b4cb
movb $0x1, %cl
testb %al, %al
jne 0x2f456
movq 0x18(%rbx), %rdi
callq 0x9b4cb
testb %al, %al
je 0x2f45d
xorl %ecx, %ecx
movb %cl, 0x20(%rbx)
xorl %eax, %eax
popq %rbx
retq
movq 0x408b04(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b5ba5(%rip), %rsi    # 0x2e5013
leaq 0x2ba932(%rip), %rdx    # 0x2e9da7
leaq 0x2bfe33(%rip), %rcx    # 0x2ef2af
leaq 0x2bfcb7(%rip), %r8     # 0x2ef13a
movl $0x8c, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390