// File: /workspace/github_c_makefile_star2_O2/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 0x2e608
movq %rdi, %r14
leaq 0x2c02ab(%rip), %rdi    # 0x2ee271
leaq 0x2c02e3(%rip), %rsi    # 0x2ee2b0
callq 0x97df5
movq %rax, %rbx
movq (%r14), %rdx
leaq 0x336669(%rip), %rdi    # 0x364648
leaq 0x2c02ff(%rip), %rsi    # 0x2ee2e5
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rax, %rdi
callq 0x9ae37
movq %r15, %rdi
callq 0x9b445
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
movq 0x10(%r14), %rdx
leaq 0x314308(%rip), %rdi    # 0x34231e
leaq 0x2c02fa(%rip), %rsi    # 0x2ee317
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rax, %rdi
callq 0x9ae37
movq %r15, %rdi
callq 0x9b445
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x61(%r14), %rdx
leaq 0x2c0356(%rip), %rdi    # 0x2ee3a3
leaq 0x2c0353(%rip), %rsi    # 0x2ee3a7
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, %rdi
callq 0x9b445
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x66(%r14), %rdx
leaq 0x2c034c(%rip), %rdi    # 0x2ee3c8
leaq 0x2c0350(%rip), %rsi    # 0x2ee3d3
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, %rdi
callq 0x9b445
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x67(%r14), %rdx
leaq 0x2c0344(%rip), %rdi    # 0x2ee3ef
leaq 0x2c0346(%rip), %rsi    # 0x2ee3f8
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r12
movq %rax, %rdi
callq 0x9b445
movq %r12, %rdi
movq %r15, %rsi
callq 0x9b38d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97f31
leaq 0x68(%r14), %rdx
leaq 0x2c033d(%rip), %rdi    # 0x2ee422
leaq 0x2c0343(%rip), %rsi    # 0x2ee42f
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r13
movq %rax, %rdi
callq 0x9b445
movq %r13, %rdi
movq %r15, 0x10(%rsp)
movq %r15, %rsi
callq 0x9b38d
movq %r13, %rdi
movq %r12, %rsi
movq %r12, 0x8(%rsp)
callq 0x9b38d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x97f31
leaq 0x69(%r14), %rdx
leaq 0x2c00e6(%rip), %rdi    # 0x2ee21a
leaq 0x2c0314(%rip), %rsi    # 0x2ee44f
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %rbp
movq %rax, %rdi
callq 0x9b445
movq %rbp, %rdi
movq %r15, %rsi
callq 0x9b38d
movq %rbp, %rdi
movq %r12, %rsi
callq 0x9b38d
movq %rbp, %rdi
movq %r13, %rsi
callq 0x9b38d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x97f31
movq 0x80(%r14), %rdx
leaq 0x2c65b4(%rip), %rdi    # 0x2f473b
leaq 0x2c02e5(%rip), %rsi    # 0x2ee473
callq 0x9ad7e
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x28(%r14), %rdx
leaq 0x2c046d(%rip), %rdi    # 0x2ee619
leaq 0x2c0470(%rip), %rsi    # 0x2ee623
leaq 0x2c04de(%rip), %rcx    # 0x2ee698
callq 0x9ad12
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97f31
movq 0x18(%r14), %rdx
leaq 0x2efd79(%rip), %rdi    # 0x31df5c
leaq 0x2c04b3(%rip), %rsi    # 0x2ee69d
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x9b38d
movq %r15, %rdi
movq %r12, %rsi
callq 0x9ae7a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97f31
leaq 0x30(%r14), %rdx
leaq 0x2c05f1(%rip), %rdi    # 0x2ee811
leaq 0x2c05b6(%rip), %rsi    # 0x2ee7dd
pushq $0x3
popq %rcx
pushq $0x2
popq %r15
movq %r15, %r8
callq 0x9ac58
movq %rax, %r12
movq %rax, %rdi
callq 0x9b0c7
movq %r12, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97f31
leaq 0x40(%r14), %rdx
leaq 0x2c05aa(%rip), %rdi    # 0x2ee80c
leaq 0x2c05ad(%rip), %rsi    # 0x2ee816
pushq $0x1
popq %r12
movq %r15, %rcx
movq %r12, %r8
callq 0x9ac58
movq %rax, %r15
movq %rax, %rdi
callq 0x9b0c7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x58(%r14), %rdx
leaq 0x2c0596(%rip), %rdi    # 0x2ee83a
leaq 0x2c0594(%rip), %rsi    # 0x2ee83f
pushq $0x78
popq %rcx
callq 0x9a9e6
movq %rax, %r15
movq %rax, %rdi
callq 0x9b0c7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x70(%r14), %rdx
leaq 0x2c0591(%rip), %rdi    # 0x2ee870
leaq 0x2c0591(%rip), %rsi    # 0x2ee877
movsd 0x2bfeda(%rip), %xmm0   # 0x2ee1c8
movsd 0x2b7f32(%rip), %xmm2   # 0x2e6228
xorps %xmm1, %xmm1
callq 0x9ab20
movq %rax, %r15
movq %rax, %rdi
callq 0x9b0c7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x78(%r14), %rdx
leaq 0x2c0631(%rip), %rdi    # 0x2ee95b
leaq 0x2c0631(%rip), %rsi    # 0x2ee962
movsd 0x2bfe97(%rip), %xmm0   # 0x2ee1d0
xorps %xmm1, %xmm1
movsd 0x2b7ee4(%rip), %xmm2   # 0x2e6228
callq 0x9ab20
movq %rax, %r15
movq %rax, %rdi
callq 0x9b445
movq %r15, %rdi
callq 0x9b0c7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x50(%r14), %rdx
leaq 0x2c06b7(%rip), %rdi    # 0x2eea34
leaq 0x2c06b8(%rip), %rsi    # 0x2eea3c
pushq $0x15
popq %rcx
callq 0x9a9e6
movq %rax, %r15
movq %rax, %rdi
callq 0x9b0c7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x48(%r14), %rdx
leaq 0x2c069c(%rip), %rdi    # 0x2eea54
leaq 0x2c069c(%rip), %rsi    # 0x2eea5b
movq %r12, %rcx
movq %r12, %r8
callq 0x9ac58
movq %rax, %r15
movq %rax, %rdi
callq 0x9b0c7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x65(%r14), %rdx
leaq 0x2c0719(%rip), %rdi    # 0x2eeb0f
leaq 0x2c0720(%rip), %rsi    # 0x2eeb1d
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, %rdi
callq 0x9b0c7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x38(%r14), %rdx
leaq 0x2c0712(%rip), %rdi    # 0x2eeb42
leaq 0x2c0713(%rip), %rsi    # 0x2eeb4a
pushq $-0x1
popq %rcx
callq 0x9a9e6
movq %rax, %r15
movq %rax, %rdi
callq 0x9b445
movq %r15, %rdi
callq 0x9b0c7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
movq 0x8(%r14), %rdx
leaq 0x2c0704(%rip), %rdi    # 0x2eeb77
leaq 0x2c0701(%rip), %rsi    # 0x2eeb7b
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rax, %rdi
callq 0x9b0c7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
movq 0x20(%r14), %rdx
leaq 0x304c1c(%rip), %rdi    # 0x3330be
leaq 0x2c07e9(%rip), %rsi    # 0x2eec92
leaq 0x2f4375(%rip), %rcx    # 0x322825
callq 0x9ad12
movq %rax, %r12
movq %rax, %rdi
callq 0x9b0c7
movq %r12, %rdi
movq %r15, %rsi
callq 0x9b14d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x97f31
leaq 0x63(%r14), %rdx
leaq 0x321d1d(%rip), %rdi    # 0x3501fe
leaq 0x2c07dc(%rip), %rsi    # 0x2eecc4
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x6a(%r14), %rdx
leaq 0x2c07e3(%rip), %rdi    # 0x2eecf3
leaq 0x2c07eb(%rip), %rsi    # 0x2eed02
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, %rdi
callq 0x9b10a
movq %r15, %rdi
movq 0x10(%rsp), %rsi
callq 0x9b38d
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x9b38d
movq %r15, %rdi
movq %r13, %rsi
callq 0x9b38d
movq %r15, %rdi
movq %rbp, %rsi
callq 0x9b38d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x62(%r14), %rdx
leaq 0x2c089b(%rip), %rdi    # 0x2eee0a
leaq 0x2c0898(%rip), %rsi    # 0x2eee0e
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
leaq 0x64(%r14), %rdx
leaq 0x2c08cb(%rip), %rdi    # 0x2eee69
leaq 0x2c08d2(%rip), %rsi    # 0x2eee77
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rax, %rdi
callq 0x9b10a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x97f31
addq $0x60, %r14
movq %r14, %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0xb8f0c(%rip), %rsi     # 0xe74ec
movq %rbx, %rdi
xorl %edx, %edx
callq 0x98045
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x98c6b
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x409959(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b69fa(%rip), %rsi    # 0x2e5013
leaq 0x31a033(%rip), %rdx    # 0x348653
leaq 0x2bfc31(%rip), %rcx    # 0x2ee258
leaq 0x2bfc17(%rip), %r8     # 0x2ee245
pushq $0x47
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390