// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_hop.c
// Function: gt_hop_option_parser_new
static GtOptionParser* gt_hop_option_parser_new(void *tool_arguments)
{
  GtHopArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *option, *ann_option, *aggressive_option, *conservative_option,
           *moderate_option, *expert_option, *o_option, *reads_option,
           *stats_option;
  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("-<mode> -c <encseq> -map <sam/bam> "
      "-reads <fastq> [options...]",
      "Cognate sequence-based homopolymer error correction.");

  /* -c */
  option = gt_option_new_string("c",
      "cognate sequence\n"
      "(encoded using gt encseq encode)",
      arguments->encseqinput, NULL);
  gt_option_is_mandatory(option);
  gt_option_hide_default(option);
  gt_option_parser_add_option(op, option);

  /* -map */
  option = gt_option_new_string("map",
      "mapping of reads to the cognate sequence\n"
      "it must be in SAM/BAM format, and sorted by coordinate\n"
      "(can be prepared e.g. using: samtools sort)",
      arguments->map, NULL);
  gt_option_is_mandatory(option);
  gt_option_hide_default(option);
  gt_option_parser_add_option(op, option);

  /* -sam */
  option = gt_option_new_bool("sam",
      "mapping file is SAM\ndefault: BAM",
      &arguments->map_is_sam, false);
  gt_option_hide_default(option);
  gt_option_parser_add_option(op, option);

  /* -aggressive */
  aggressive_option = gt_option_new_bool("aggressive",
      "correct as much as possible",
       &arguments->aggressive, false);
  gt_option_hide_default(aggressive_option);
  gt_option_parser_add_option(op, aggressive_option);

  /* -moderate */
  moderate_option = gt_option_new_bool("moderate",
      "mediate between sensitivity and precision",
      &arguments->moderate, false);
  gt_option_hide_default(moderate_option);
  gt_option_exclude(moderate_option, aggressive_option);
  gt_option_parser_add_option(op, moderate_option);

  /* -conservative */
  conservative_option = gt_option_new_bool("conservative",
      "correct only most likely errors",
      &arguments->conservative, false);
  gt_option_hide_default(conservative_option);
  gt_option_exclude(conservative_option, aggressive_option);
  gt_option_exclude(conservative_option, moderate_option);
  gt_option_parser_add_option(op, conservative_option);

  /* -expert */
  expert_option = gt_option_new_bool("expert",
      "manually select correction criteria",
      &arguments->expert, false);
  gt_option_hide_default(expert_option);
  gt_option_exclude(expert_option, aggressive_option);
  gt_option_exclude(expert_option, moderate_option);
  gt_option_exclude(expert_option, conservative_option);
  gt_option_parser_add_option(op, expert_option);

  /* -reads */
  reads_option = gt_option_new_filename_array("reads",
      "uncorrected read file(s) in FastQ format;\n"
      "the corrected reads are output in the currect working directory "
      "in files which are named as the input files, each prepended "
      "by a prefix (see -outprefix option)\n"
      "-reads allows one to output the reads in the same order as in the input "
      "and is mandatory if the SAM contains more than a single primary "
      "alignment for each read (e.g. output of bwasw)\n"
      "see also -o option as an alternative",
      arguments->readset);
  gt_option_parser_add_option(op, reads_option);

  /* -outprefix */
  option = gt_option_new_string("outprefix",
      "prefix for output filenames (corrected reads)"
      "when -reads is specified\n"
      "the prefix is prepended to each input filename",
      arguments->outprefix, "hop_");
  gt_option_imply(option, reads_option);
  gt_option_parser_add_option(op, option);

  /* -o */
  o_option = gt_option_new_string("o", "output file for corrected reads\n"
      "(see also -reads/-outprefix) if -o is used, reads are output "
      "in a single file in the order they are found in the SAM file "
      "(which usually differ from the original order)\n"
      "this will only work if the reads were aligned with a software which "
      "only includes 1 alignment for each read (e.g. bwa)",
      arguments->outfilename, NULL);
  gt_option_exclude(reads_option, o_option);
  gt_option_is_mandatory_either(reads_option, o_option);
  gt_option_parser_add_option(op, o_option);

  /* -hmin */
  option = gt_option_new_uword_min("hmin",
      "minimal homopolymer length in cognate sequence",
      &arguments->hmin, 3UL, 2UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -read-hmin */
  option = gt_option_new_uword_min("read-hmin",
      "minimal homopolymer length in reads",
      &arguments->read_hmin, 2UL, 1UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -qmax */
  option = gt_option_new_uword("qmax",
      "maximal average quality of homopolymer in a read",
      &arguments->qmax, 120UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -altmax */
  option = gt_option_new_double_min_max("altmax",
      "max support of alternate homopol. length;\n"
      "e.g. 0.8 means: do not correct any read if homop. length in more than "
      "80%% of the reads has the same value, different from the cognate\n"
      "if altmax is set to 1.0 reads are always corrected",
      &arguments->altmax, (double) 0.8, 0.0, (double) 1.0);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -cogmin */
  option = gt_option_new_double_min_max("cogmin",
      "min support of cognate sequence homopol. length;\n"
      "e.g. 0.1 means: do not correct any read if cognate homop. length "
      "is not present in at least 10%% of the reads\n"
      "if cogmin is set to 0.0 reads are always corrected",
      &arguments->cogmin, (double) 0.1, 0.0, (double) 1.0);
  gt_option_hide_default(option);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -mapqmin */
  option = gt_option_new_uword("mapqmin",
      "minimal mapping quality",
      &arguments->mapqmin, 21UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -covmin */
  option = gt_option_new_uword_min("covmin",
      "minimal coverage;\n"
      "e.g. 5 means: do not correct any read if coverage "
      "(number of reads mapped over whole homopolymer) "
      "is less than 5\n"
      "if covmin is set to 1 reads are always corrected",
      &arguments->covmin, 1UL, 1UL);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -allow-multiple */
  option = gt_option_new_bool("allow-muliple",
      "allow multiple corrections in a read",
      &arguments->allow_multiple, false);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -clenmax */
  option = gt_option_new_uword("clenmax", "maximal correction length\n"
      "default: unlimited", &arguments->clenmax, GT_UNDEF_UWORD);
  gt_option_hide_default(option);
  gt_option_is_extended_option(option);
  gt_option_imply(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -ann */
  ann_option = gt_option_new_string("ann",
      "annotation of cognate sequence\n"
      "it must be sorted by coordinates on the cognate sequence\n"
      "(this can be e.g. done using: gt gff3 -sort)\n"
      "if -ann is used, corrections will be limited to homopolymers starting"
      "or ending inside the feature type indicated by -ft option"
      "format: sorted GFF3",
      arguments->annotation, NULL);
  gt_option_is_extended_option(ann_option);
  gt_option_parser_add_option(op, ann_option);

  /* -ft */
  option = gt_option_new_string("ft", "feature type to use when -ann option "
      "is specified",
      arguments->atype, gt_ft_CDS);
  gt_option_is_extended_option(option);
  gt_option_imply(option, ann_option);
  gt_option_parser_add_option(op, option);

  /* -stats */
  stats_option = gt_option_new_bool("stats", "output statistics for each "
      "correction position", &arguments->stats, false);
  gt_option_is_development_option(stats_option);
  gt_option_parser_add_option(op, stats_option);

  /* -state-of-truth */
  option = gt_option_new_bool("state-of-truth",
      "similar to -stats in -aggressive "
      "mode, but used to determine the \"state of truth\" set of corrections "
      "for evaluation; currently the only difference is that if multiple hits "
      "are present for a read, they are used all independently for "
      "correction (-reads must be set)",
      &arguments->state_of_truth, false);
  gt_option_is_development_option(option);
  gt_option_exclude(option, aggressive_option);
  gt_option_exclude(option, moderate_option);
  gt_option_exclude(option, conservative_option);
  gt_option_exclude(option, expert_option);
  gt_option_parser_add_option(op, option);

  /* -chk */
  option = gt_option_new_bool("chk", "debug option; check that cognate region "
      "of aligned segments is compatible with encseq data",
      &arguments->chk, false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

  /* -allow-partial */
  option = gt_option_new_bool("allow-partial",
      "allow insertions also if there are less gaps in read homopolymer "
      "than the difference in length with the cognate sequence\n"
      "(at most as many symbols as the gaps will be inserted)",
      &arguments->allow_partial, false);
  gt_option_is_development_option(option);
  gt_option_parser_add_option(op, option);

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

  gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);

  gt_option_parser_set_min_max_args(op, 0, 0);

  return op;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xadddb
movq %rdi, %r14
leaq 0x2a9b17(%rip), %rdi    # 0x3572a1
leaq 0x2a9b4f(%rip), %rsi    # 0x3572e0
callq 0x10cc4e
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x3201bd(%rip), %rdi    # 0x3cd960
leaq 0x2a9b6b(%rip), %rsi    # 0x357315
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %r15, %rdi
callq 0x10fe32
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x10(%r14), %rdx
leaq 0x2fddb4(%rip), %rdi    # 0x3ab58e
leaq 0x2a9b66(%rip), %rsi    # 0x357347
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fa96
movq %r15, %rdi
callq 0x10fe32
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x61(%r14), %rdx
leaq 0x2a9bc2(%rip), %rdi    # 0x3573d3
leaq 0x2a9bbf(%rip), %rsi    # 0x3573d7
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, %rdi
callq 0x10fe32
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x66(%r14), %rdx
leaq 0x2a9bb8(%rip), %rdi    # 0x3573f8
leaq 0x2a9bbc(%rip), %rsi    # 0x357403
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, %rdi
callq 0x10fe32
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x67(%r14), %rdx
leaq 0x2a9bb0(%rip), %rdi    # 0x35741f
leaq 0x2a9bb2(%rip), %rsi    # 0x357428
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r12
movq %rax, %rdi
callq 0x10fe32
movq %r12, %rdi
movq %r15, %rsi
callq 0x10fd9f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10cd10
leaq 0x68(%r14), %rdx
leaq 0x2a9ba9(%rip), %rdi    # 0x357452
leaq 0x2a9baf(%rip), %rsi    # 0x35745f
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r13
movq %rax, %rdi
callq 0x10fe32
movq %r13, %rdi
movq %r15, 0x10(%rsp)
movq %r15, %rsi
callq 0x10fd9f
movq %r13, %rdi
movq %r12, %rsi
movq %r12, 0x8(%rsp)
callq 0x10fd9f
movq %rbx, %rdi
movq %r13, %rsi
callq 0x10cd10
leaq 0x69(%r14), %rdx
leaq 0x2a9952(%rip), %rdi    # 0x35724a
leaq 0x2a9b80(%rip), %rsi    # 0x35747f
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %rbp
movq %rax, %rdi
callq 0x10fe32
movq %rbp, %rdi
movq %r15, %rsi
callq 0x10fd9f
movq %rbp, %rdi
movq %r12, %rsi
callq 0x10fd9f
movq %rbp, %rdi
movq %r13, %rsi
callq 0x10fd9f
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x10cd10
movq 0x80(%r14), %rdx
leaq 0x2afe18(%rip), %rdi    # 0x35d763
leaq 0x2a9b51(%rip), %rsi    # 0x3574a3
callq 0x10f9f6
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x28(%r14), %rdx
leaq 0x2a9cd9(%rip), %rdi    # 0x357649
leaq 0x2a9cdc(%rip), %rsi    # 0x357653
leaq 0x2a9d4a(%rip), %rcx    # 0x3576c8
callq 0x10f987
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10cd10
movq 0x18(%r14), %rdx
leaq 0x2d951d(%rip), %rdi    # 0x386ec4
leaq 0x2a9d1f(%rip), %rsi    # 0x3576cd
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x10fd9f
movq %r15, %rdi
movq %r12, %rsi
callq 0x10faa6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10cd10
leaq 0x30(%r14), %rdx
leaq 0x2a9e5d(%rip), %rdi    # 0x357841
leaq 0x2a9e22(%rip), %rsi    # 0x35780d
movl $0x3, %ecx
movl $0x2, %r8d
callq 0x10f7ed
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbdf
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x40(%r14), %rdx
leaq 0x2a9e15(%rip), %rdi    # 0x35783c
leaq 0x2a9e18(%rip), %rsi    # 0x357846
movl $0x2, %ecx
movl $0x1, %r8d
callq 0x10f7ed
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbdf
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x58(%r14), %rdx
leaq 0x2a9e00(%rip), %rdi    # 0x35786a
leaq 0x2a9dfe(%rip), %rsi    # 0x35786f
movl $0x78, %ecx
callq 0x10f4c7
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbdf
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x70(%r14), %rdx
leaq 0x2a9df9(%rip), %rdi    # 0x3578a0
leaq 0x2a9df9(%rip), %rsi    # 0x3578a7
movsd 0x2a9742(%rip), %xmm0   # 0x3571f8
movsd 0x2a176a(%rip), %xmm2   # 0x34f228
xorps %xmm1, %xmm1
callq 0x10f5d1
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbdf
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x78(%r14), %rdx
leaq 0x2a9e99(%rip), %rdi    # 0x35798b
leaq 0x2a9e99(%rip), %rsi    # 0x357992
movsd 0x2a96ff(%rip), %xmm0   # 0x357200
xorps %xmm1, %xmm1
movsd 0x2a171c(%rip), %xmm2   # 0x34f228
callq 0x10f5d1
movq %rax, %r15
movq %rax, %rdi
callq 0x10fe32
movq %r15, %rdi
callq 0x10fbdf
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x50(%r14), %rdx
leaq 0x2a9f1f(%rip), %rdi    # 0x357a64
leaq 0x2a9f20(%rip), %rsi    # 0x357a6c
movl $0x15, %ecx
callq 0x10f4c7
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbdf
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x48(%r14), %rdx
leaq 0x2a9f02(%rip), %rdi    # 0x357a84
leaq 0x2a9f02(%rip), %rsi    # 0x357a8b
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x10f7ed
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbdf
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x65(%r14), %rdx
leaq 0x2a9f7a(%rip), %rdi    # 0x357b3f
leaq 0x2a9f81(%rip), %rsi    # 0x357b4d
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbdf
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x38(%r14), %rdx
leaq 0x2a9f73(%rip), %rdi    # 0x357b72
leaq 0x2a9f74(%rip), %rsi    # 0x357b7a
movq $-0x1, %rcx
callq 0x10f4c7
movq %rax, %r15
movq %rax, %rdi
callq 0x10fe32
movq %r15, %rdi
callq 0x10fbdf
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x8(%r14), %rdx
leaq 0x2a9f61(%rip), %rdi    # 0x357ba7
leaq 0x2a9f5e(%rip), %rsi    # 0x357bab
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbdf
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x20(%r14), %rdx
leaq 0x2ee559(%rip), %rdi    # 0x39c1ce
leaq 0x2aa046(%rip), %rsi    # 0x357cc2
leaq 0x2ddb59(%rip), %rcx    # 0x38b7dc
callq 0x10f987
movq %rax, %r12
movq %rax, %rdi
callq 0x10fbdf
movq %r12, %rdi
movq %r15, %rsi
callq 0x10fbff
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10cd10
leaq 0x63(%r14), %rdx
leaq 0x30b702(%rip), %rdi    # 0x3b93b6
leaq 0x2aa039(%rip), %rsi    # 0x357cf4
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x6a(%r14), %rdx
leaq 0x2aa040(%rip), %rdi    # 0x357d23
leaq 0x2aa048(%rip), %rsi    # 0x357d32
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbef
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x10fd9f
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x10fd9f
movq %r15, %rdi
movq %r13, %rsi
callq 0x10fd9f
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10fd9f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x62(%r14), %rdx
leaq 0x2aa0f8(%rip), %rdi    # 0x357e3a
leaq 0x2aa0f5(%rip), %rsi    # 0x357e3e
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
leaq 0x64(%r14), %rdx
leaq 0x2aa128(%rip), %rdi    # 0x357e99
leaq 0x2aa12f(%rip), %rsi    # 0x357ea7
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
addq $0x60, %r14
movq %r14, %rdi
callq 0x10f473
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0xa60e9(%rip), %rsi     # 0x153e9c
movq %rbx, %rdi
xorl %edx, %edx
callq 0x10cd8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10d784
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1bb3f