// File: /workspace/github_c_makefile_star2_O3/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 0xaba84
movq %rdi, %r14
leaq 0x2a2e3e(%rip), %rdi    # 0x34e271
leaq 0x2a2e76(%rip), %rsi    # 0x34e2b0
callq 0x107bfe
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x318dec(%rip), %rdi    # 0x3c4238
leaq 0x2a2e92(%rip), %rsi    # 0x34e2e5
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10a87b
movq %r15, %rdi
callq 0x10ac1f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x10(%r14), %rdx
leaq 0x2f6bab(%rip), %rdi    # 0x3a202e
leaq 0x2a2e8d(%rip), %rsi    # 0x34e317
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10a87b
movq %r15, %rdi
callq 0x10ac1f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x61(%r14), %rdx
leaq 0x2a2ee9(%rip), %rdi    # 0x34e3a3
leaq 0x2a2ee6(%rip), %rsi    # 0x34e3a7
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10ac1f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x66(%r14), %rdx
leaq 0x2a2edf(%rip), %rdi    # 0x34e3c8
leaq 0x2a2ee3(%rip), %rsi    # 0x34e3d3
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10ac1f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x67(%r14), %rdx
leaq 0x2a2ed7(%rip), %rdi    # 0x34e3ef
leaq 0x2a2ed9(%rip), %rsi    # 0x34e3f8
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r12
movq %rax, %rdi
callq 0x10ac1f
movq %r12, %rdi
movq %r15, %rsi
callq 0x10ab96
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107cc0
leaq 0x68(%r14), %rdx
leaq 0x2a2ed0(%rip), %rdi    # 0x34e422
leaq 0x2a2ed6(%rip), %rsi    # 0x34e42f
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r13
movq %rax, %rdi
callq 0x10ac1f
movq %r13, %rdi
movq %r15, 0x10(%rsp)
movq %r15, %rsi
callq 0x10ab96
movq %r13, %rdi
movq %r12, %rsi
movq %r12, 0x8(%rsp)
callq 0x10ab96
movq %rbx, %rdi
movq %r13, %rsi
callq 0x107cc0
leaq 0x69(%r14), %rdx
leaq 0x2a2c79(%rip), %rdi    # 0x34e21a
leaq 0x2a2ea7(%rip), %rsi    # 0x34e44f
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %rbp
movq %rax, %rdi
callq 0x10ac1f
movq %rbp, %rdi
movq %r15, %rsi
callq 0x10ab96
movq %rbp, %rdi
movq %r12, %rsi
callq 0x10ab96
movq %rbp, %rdi
movq %r13, %rsi
callq 0x10ab96
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x107cc0
movq 0x80(%r14), %rdx
leaq 0x2a9137(%rip), %rdi    # 0x35472b
leaq 0x2a2e78(%rip), %rsi    # 0x34e473
callq 0x10a7df
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x28(%r14), %rdx
leaq 0x2a3000(%rip), %rdi    # 0x34e619
leaq 0x2a3003(%rip), %rsi    # 0x34e623
leaq 0x2a3071(%rip), %rcx    # 0x34e698
callq 0x10a770
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107cc0
movq 0x18(%r14), %rdx
leaq 0x2d2504(%rip), %rdi    # 0x37db54
leaq 0x2a3046(%rip), %rsi    # 0x34e69d
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x10ab96
movq %r15, %rdi
movq %r12, %rsi
callq 0x10a88b
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107cc0
leaq 0x30(%r14), %rdx
leaq 0x2a3184(%rip), %rdi    # 0x34e811
leaq 0x2a3149(%rip), %rsi    # 0x34e7dd
movl $0x3, %ecx
movl $0x2, %r8d
callq 0x10a5d1
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x40(%r14), %rdx
leaq 0x2a313c(%rip), %rdi    # 0x34e80c
leaq 0x2a313f(%rip), %rsi    # 0x34e816
movl $0x2, %ecx
movl $0x1, %r8d
callq 0x10a5d1
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x58(%r14), %rdx
leaq 0x2a3127(%rip), %rdi    # 0x34e83a
leaq 0x2a3125(%rip), %rsi    # 0x34e83f
movl $0x78, %ecx
callq 0x10a2ab
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x70(%r14), %rdx
leaq 0x2a3120(%rip), %rdi    # 0x34e870
leaq 0x2a3120(%rip), %rsi    # 0x34e877
movsd 0x2a2a69(%rip), %xmm0   # 0x34e1c8
movsd 0x29aac1(%rip), %xmm2   # 0x346228
xorps %xmm1, %xmm1
callq 0x10a3b5
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x78(%r14), %rdx
leaq 0x2a31c0(%rip), %rdi    # 0x34e95b
leaq 0x2a31c0(%rip), %rsi    # 0x34e962
movsd 0x2a2a26(%rip), %xmm0   # 0x34e1d0
xorps %xmm1, %xmm1
movsd 0x29aa73(%rip), %xmm2   # 0x346228
callq 0x10a3b5
movq %rax, %r15
movq %rax, %rdi
callq 0x10ac1f
movq %r15, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x50(%r14), %rdx
leaq 0x2a3246(%rip), %rdi    # 0x34ea34
leaq 0x2a3247(%rip), %rsi    # 0x34ea3c
movl $0x15, %ecx
callq 0x10a2ab
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x48(%r14), %rdx
leaq 0x2a3229(%rip), %rdi    # 0x34ea54
leaq 0x2a3229(%rip), %rsi    # 0x34ea5b
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x10a5d1
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x65(%r14), %rdx
leaq 0x2a32a1(%rip), %rdi    # 0x34eb0f
leaq 0x2a32a8(%rip), %rsi    # 0x34eb1d
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x38(%r14), %rdx
leaq 0x2a329a(%rip), %rdi    # 0x34eb42
leaq 0x2a329b(%rip), %rsi    # 0x34eb4a
movq $-0x1, %rcx
callq 0x10a2ab
movq %rax, %r15
movq %rax, %rdi
callq 0x10ac1f
movq %r15, %rdi
callq 0x10a9c4
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x8(%r14), %rdx
leaq 0x2a3288(%rip), %rdi    # 0x34eb77
leaq 0x2a3285(%rip), %rsi    # 0x34eb7b
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9c4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x20(%r14), %rdx
leaq 0x2e7447(%rip), %rdi    # 0x392d65
leaq 0x2a336d(%rip), %rsi    # 0x34ec92
leaq 0x2d6aed(%rip), %rcx    # 0x382419
callq 0x10a770
movq %rax, %r12
movq %rax, %rdi
callq 0x10a9c4
movq %r12, %rdi
movq %r15, %rsi
callq 0x10a9e4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107cc0
leaq 0x63(%r14), %rdx
leaq 0x304459(%rip), %rdi    # 0x3afdb6
leaq 0x2a3360(%rip), %rsi    # 0x34ecc4
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x6a(%r14), %rdx
leaq 0x2a3367(%rip), %rdi    # 0x34ecf3
leaq 0x2a336f(%rip), %rsi    # 0x34ed02
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x10ab96
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x10ab96
movq %r15, %rdi
movq %r13, %rsi
callq 0x10ab96
movq %r15, %rdi
movq %rbp, %rsi
callq 0x10ab96
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x62(%r14), %rdx
leaq 0x2a341f(%rip), %rdi    # 0x34ee0a
leaq 0x2a341c(%rip), %rsi    # 0x34ee0e
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
leaq 0x64(%r14), %rdx
leaq 0x2a344f(%rip), %rdi    # 0x34ee69
leaq 0x2a3456(%rip), %rsi    # 0x34ee77
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
addq $0x60, %r14
movq %r14, %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0xa0e68(%rip), %rsi     # 0x14c8c4
movq %rbx, %rdi
xorl %edx, %edx
callq 0x107d3d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10874b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1ba43