// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/tools/gt_repfind.c
// Function: gt_repfind_option_parser_new
static GtOptionParser *gt_repfind_option_parser_new(void *tool_arguments)
{
  const GtUword extension_sensitivity = 97;
  GtOptionParser *op;
  GtOption *option, *reverseoption, *reverse_complementoption,
           *option_query_files, *extendxdropoption,
           *extendgreedyoption, *scanoption, *sampleoption, *forwardoption,
           *spmoption, *seedlengthoption, *minidentityoption,
           *maxalilendiffoption, *leastlength_option, *char_access_mode_option,
           *check_extend_symmetry_option, *xdropbelowoption, *historyoption,
           *percmathistoryoption, *errorpercentageoption, *optiontrimstat,
           *optionnoxpolish, *verify_alignment_option, *option_query_indexname,
           *op_evalue;
  GtMaxpairsoptions *arguments = tool_arguments;

  op = gt_option_parser_new("[options] -ii indexname",
                                  "Compute maximal exact matches (and more).");
  gt_option_parser_set_mail_address(op,"<kurtz@zbh.uni-hamburg.de>");

  leastlength_option
    = gt_option_new_uint("l","Specify minimum length of matches",
                         &arguments->userdefinedleastlength,
                         0U);
  gt_option_parser_add_option(op, leastlength_option);
  arguments->refuserdefinedleastlengthoption
    = gt_option_ref(leastlength_option);

  forwardoption = gt_option_new_bool("f","Compute forward matches",
                                     &arguments->forward,
                                     true);
  gt_option_parser_add_option(op, forwardoption);
  arguments->refforwardoption = gt_option_ref(forwardoption);

  reverseoption = gt_option_new_bool("r","Compute reverse matches",
                                     &arguments->reverse,
                                     false);
  gt_option_parser_add_option(op, reverseoption);

  reverse_complementoption = gt_option_new_bool("p",
                                        "Compute matches on reverse strand",
                                        &arguments->reverse_complement,
                                        false);
  gt_option_parser_add_option(op, reverse_complementoption);

  seedlengthoption = gt_option_new_uint_min("seedlength",
                                             "Specify minimum length of seed",
                                             &arguments->seedlength,
                                             0,
                                             1UL);
  gt_option_parser_add_option(op, seedlengthoption);
  arguments->refseedlengthoption = gt_option_ref(seedlengthoption);

  option = gt_option_new_uword_min("maxfreq",
                                   "Specify maximal frequency of maximal exact "
                                   "matches in reference sequence",
                                   &arguments->maxfreq,
                                   0,
                                   2UL);
  gt_option_parser_add_option(op, option);

  extendxdropoption
    = gt_option_new_uword_min_max("extendxdrop",
                         "Extend seed to both sides using xdrop algorithm, "
                         "optional parameter specifies sensitivity",
                         &arguments->extendxdrop,
                         extension_sensitivity, 90, 100);
  gt_option_argument_is_optional(extendxdropoption);
  gt_option_parser_add_option(op, extendxdropoption);
  arguments->refextendxdropoption = gt_option_ref(extendxdropoption);

  xdropbelowoption = gt_option_new_word("xdropbelow",
                                        "Specify xdrop cutoff score "
                                        "(argument 0 means undefined). If "
                                        "undefined an optimal value is "
                                        "determined automatically depending "
                                        "on the error "
                                        "rate",
                                        &arguments->xdropbelowscore,
                                        0);
  gt_option_parser_add_option(op, xdropbelowoption);

  extendgreedyoption
    = gt_option_new_uword_min_max("extendgreedy",
                                  "Extend seed to both sides using "
                                  "greedy algorithm with trimming of waves, "
                                  "optional parameter specifies sensitivity",
                                  &arguments->extendgreedy,
                                  extension_sensitivity, 90, 100);
  gt_option_argument_is_optional(extendgreedyoption);
  gt_option_parser_add_option(op, extendgreedyoption);
  arguments->refextendgreedyoption = gt_option_ref(extendgreedyoption);

  errorpercentageoption
    = gt_option_new_uword_min_max("err","Specify error percentage of matches "
                         "as integer in the range from 1 to 30 "
                         "(for xdrop and greedy extension) [deprecated option, "
                         "kept for backwards compatibility]",
                         &arguments->minidentity,
                         10,
                         1,
                         100 - GT_EXTEND_MIN_IDENTITY_PERCENTAGE);
  gt_option_is_development_option(errorpercentageoption);
  gt_option_parser_add_option(op, errorpercentageoption);

  minidentityoption
    = gt_option_new_uword_min_max("minidentity",
                          "Specify minimum identity of matches\n"
                          "as integer in the range from 70 to 99 "
                          "(for xdrop and greedy extension)",
                          &arguments->minidentity,
                          80,
                          GT_EXTEND_MIN_IDENTITY_PERCENTAGE,99);
  gt_option_parser_add_option(op, minidentityoption);

  maxalilendiffoption
    = gt_option_new_uword("maxalilendiff","Specify maximum difference of "
                          "alignment length (trimming for greedy extension), "
                          "if option is not used or parameter 0 is specified, "
                          "then good value is automatically chosen",
                          &arguments->maxalignedlendifference,
                          0);
  gt_option_parser_add_option(op, maxalilendiffoption);
  gt_option_is_development_option(maxalilendiffoption);

  historyoption
    = gt_option_new_uword_min_max("history",
                                  "Specify size of history in range [1..64] "
                                  "(trimming for greedy extension)",
                                  &arguments->historysize,
                                  60,
                                  0,
                                  64);
  gt_option_parser_add_option(op, historyoption);
  gt_option_is_development_option(historyoption);

  percmathistoryoption
    = gt_option_new_uword_min_max("percmathistory",
                                  "percentage of matches required in history",
                                  &arguments->perc_mat_history,
                                  0,
                                  1,
                                  100);
  gt_option_parser_add_option(op, percmathistoryoption);
  gt_option_is_development_option(percmathistoryoption);

  option = gt_option_new_string("ii",
                                "Specify input index",
                                arguments->indexname, NULL);
  gt_option_parser_add_option(op, option);
  gt_option_is_mandatory(option);

  char_access_mode_option = gt_option_new_string("cam",
                                                 gt_cam_extendgreedy_comment(),
                                                 arguments->cam_string,
                                                 "any,any");
  gt_option_parser_add_option(op, char_access_mode_option);
  gt_option_is_development_option(char_access_mode_option);

  /* -outfmt */
  option = gt_option_new_string_array("outfmt",
                                      gt_querymatch_display_help(),
                                      arguments->display_args);
  gt_option_parser_add_option(op, option);

  /* -evalue */
  op_evalue = gt_option_new_double("evalue","switch on evalue filtering of "
                                            "matches (optional argument "
                                            "specifies evalue threshold)",
                                   &arguments->evalue_threshold,
                                   10.0);
  gt_option_parser_add_option(op, op_evalue);
  gt_option_argument_is_optional(op_evalue);
  arguments->ref_op_evalue = gt_option_ref(op_evalue);

  optionnoxpolish
    = gt_option_new_bool("noxpolish","do not polish X-drop extensions",
                         &arguments->noxpolish, false);
  gt_option_parser_add_option(op, optionnoxpolish);
  gt_option_is_development_option(optionnoxpolish);

  verify_alignment_option
    = gt_option_new_bool("verify-alignment","verify correctness of alignments",
                         &arguments->verify_alignment, false);
  gt_option_parser_add_option(op, verify_alignment_option);
  gt_option_is_development_option(verify_alignment_option);

  optiontrimstat = gt_option_new_bool("trimstat","show trimming statistics",
                                      &arguments->trimstat_on, false);
  gt_option_parser_add_option(op, optiontrimstat);
  gt_option_is_development_option(optiontrimstat);

  option_query_indexname = gt_option_new_string("qii",
                                                "Specify name of query index",
                                                arguments->query_indexname,
                                                NULL);
  gt_option_is_development_option(option_query_indexname);
  gt_option_parser_add_option(op, option_query_indexname);

  /* the following option are options special to repfind */

  option_query_files = gt_option_new_filename_array("q",
                                                    "Specify query files",
                                                    arguments->query_files);
  gt_option_is_development_option(option_query_files);
  gt_option_parser_add_option(op, option_query_files);

  sampleoption = gt_option_new_uword_min("samples","Specify number of samples",
                                         &arguments->samples,
                                         0,
                                         1UL);
  gt_option_is_development_option(sampleoption);
  gt_option_parser_add_option(op, sampleoption);

  spmoption = gt_option_new_bool("spm","Search for suffix prefix matches",
                                       &arguments->searchspm,
                                       false);
  gt_option_is_development_option(spmoption);
  gt_option_parser_add_option(op, spmoption);

  check_extend_symmetry_option
    = gt_option_new_bool("check_extend_symmetry",
                         "check that left/right greedy extension is symmetric "
                         "for sequences mirror around seed",
                         &arguments->check_extend_symmetry,
                         false);
  gt_option_parser_add_option(op, check_extend_symmetry_option);
  gt_option_is_development_option(check_extend_symmetry_option);

  scanoption = gt_option_new_bool("scan","scan index rather than map "
                                         "it to main memory",
                                  &arguments->scanfile,
                                  false);
  gt_option_parser_add_option(op, scanoption);

  option = gt_option_new_verbose(&arguments->beverbose);
  gt_option_parser_add_option(op, option);

  gt_option_exclude(option_query_files,sampleoption);
  gt_option_exclude(option_query_files,scanoption);
  gt_option_exclude(option_query_files,spmoption);
  gt_option_exclude(option_query_files,option_query_indexname);
  gt_option_exclude(sampleoption,spmoption);
  gt_option_exclude(reverseoption,spmoption);
  gt_option_exclude(reverse_complementoption,spmoption);
  gt_option_exclude(extendgreedyoption,extendxdropoption);
  gt_option_exclude(errorpercentageoption,minidentityoption);
  gt_option_imply(xdropbelowoption,extendxdropoption);
  gt_option_imply(historyoption,extendgreedyoption);
  gt_option_imply(maxalilendiffoption,extendgreedyoption);
  gt_option_imply(percmathistoryoption,extendgreedyoption);
  gt_option_imply(optiontrimstat,extendgreedyoption);
  gt_option_imply(optionnoxpolish,extendxdropoption);
  gt_option_imply_either_2(seedlengthoption,extendxdropoption,
                           extendgreedyoption);
  gt_option_imply_either_2(minidentityoption,extendxdropoption,
                           extendgreedyoption);
  gt_option_imply_either_2(errorpercentageoption,extendxdropoption,
                           extendgreedyoption);
  return op;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
leaq 0x29d550(%rip), %rdi    # 0x35b2d6
leaq 0x2a027a(%rip), %rsi    # 0x35e007
callq 0x10cc4e
movq %rax, %rbx
leaq 0x291530(%rip), %rsi    # 0x34f2cc
movq %rax, %rdi
callq 0x10ceab
leaq 0x2d31ab(%rip), %rdi    # 0x390f56
leaq 0x2a027f(%rip), %rsi    # 0x35e031
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10f719
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10cc3c
movq %rax, 0x90(%r14)
leaq 0x52(%r14), %rdx
leaq 0x2a84b1(%rip), %rdi    # 0x366295
leaq 0x2a0268(%rip), %rsi    # 0x35e053
movl $0x1, %ecx
callq 0x10f451
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10cc3c
movq %rax, 0x80(%r14)
leaq 0x53(%r14), %rdx
leaq 0x2a60ac(%rip), %rdi    # 0x363ec9
leaq 0x2a0247(%rip), %rsi    # 0x35e06b
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x68(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x54(%r14), %rdx
leaq 0x2e0e3f(%rip), %rdi    # 0x39ec85
leaq 0x2a0236(%rip), %rsi    # 0x35e083
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x4(%r14), %rdx
leaq 0x2eb289(%rip), %rdi    # 0x3a90f8
leaq 0x2a022f(%rip), %rsi    # 0x35e0a5
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10f73b
movq %rax, %r15
movq %rax, 0x70(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10cc3c
movq %rax, 0x88(%r14)
leaq 0x20(%r14), %rdx
leaq 0x2a0214(%rip), %rdi    # 0x35e0c4
leaq 0x2a0215(%rip), %rsi    # 0x35e0cc
movl $0x2, %r8d
xorl %ecx, %ecx
callq 0x10f7ed
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x18(%r14), %rdx
leaq 0x2a023b(%rip), %rdi    # 0x35e115
leaq 0x2a0240(%rip), %rsi    # 0x35e121
movl $0x61, %ecx
movl $0x5a, %r8d
movl $0x64, %r9d
callq 0x10f81b
movq %rax, %r15
movq %rax, 0x58(%rsp)
movq %rax, %rdi
callq 0x10fe42
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10cc3c
movq %rax, 0x98(%r14)
leaq 0x8(%r14), %rdx
leaq 0x2a024f(%rip), %rdi    # 0x35e17b
leaq 0x2a0253(%rip), %rsi    # 0x35e186
xorl %ecx, %ecx
callq 0x10f7c9
movq %rax, 0x50(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x48(%r14), %rdx
leaq 0x2a02c0(%rip), %rdi    # 0x35e215
leaq 0x2a02c6(%rip), %rsi    # 0x35e222
movl $0x61, %ecx
movl $0x5a, %r8d
movl $0x64, %r9d
callq 0x10f81b
movq %rax, %r15
movq %rax, 0x48(%rsp)
movq %rax, %rdi
callq 0x10fe42
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10cc3c
movq %rax, 0xa0(%r14)
leaq 0x38(%r14), %r15
leaq 0x2d187d(%rip), %rdi    # 0x38f824
leaq 0x2a02e6(%rip), %rsi    # 0x35e294
movl $0xa, %ecx
movl $0x1, %r8d
movl $0x1e, %r9d
movq %r15, %rdx
callq 0x10f81b
movq %rax, %r12
movq %rax, 0x40(%rsp)
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10cd10
leaq 0x2f6525(%rip), %rdi    # 0x3b450e
leaq 0x2a0344(%rip), %rsi    # 0x35e334
movl $0x50, %ecx
movl $0x46, %r8d
movl $0x63, %r9d
movq %r15, %rdx
callq 0x10f81b
movq %rax, 0x38(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x40(%r14), %rdx
leaq 0x2a037b(%rip), %rdi    # 0x35e39f
leaq 0x2a0382(%rip), %rsi    # 0x35e3ad
xorl %ecx, %ecx
callq 0x10f4c7
movq %rax, %r15
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fbef
leaq 0x28(%r14), %rdx
leaq 0x2a047a(%rip), %rdi    # 0x35e4d2
leaq 0x2a03f9(%rip), %rsi    # 0x35e458
movl $0x3c, %ecx
movl $0x40, %r9d
xorl %r8d, %r8d
callq 0x10f81b
movq %rax, %r15
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fbef
leaq 0x30(%r14), %rdx
leaq 0x2a0409(%rip), %rdi    # 0x35e4a1
leaq 0x2a0411(%rip), %rsi    # 0x35e4b0
movl $0x1, %r8d
movl $0x64, %r9d
xorl %ecx, %ecx
callq 0x10f81b
movq %rax, %r15
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fbef
movq 0x60(%r14), %rdx
leaq 0x2fe9bb(%rip), %rdi    # 0x3bca93
leaq 0x29d2db(%rip), %rsi    # 0x35b3ba
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fa96
callq 0x1e9ebd
movq 0x70(%r14), %rdx
leaq 0x2a03ce(%rip), %rdi    # 0x35e4da
leaq 0x2a03cb(%rip), %rcx    # 0x35e4de
movq %rax, %rsi
callq 0x10f987
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fbef
callq 0x1c2ab0
movq 0xb0(%r14), %rdx
leaq 0x2f685a(%rip), %rdi    # 0x3b499e
movq %rax, %rsi
callq 0x10f9b8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0xb8(%r14), %rdx
leaq 0x2c2dc6(%rip), %rdi    # 0x380f2b
leaq 0x2a037a(%rip), %rsi    # 0x35e4e6
movsd 0x29fe64(%rip), %xmm0   # 0x35dfd8
callq 0x10f562
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fe42
movq %r15, %rdi
callq 0x10cc3c
movq %rax, 0xa8(%r14)
leaq 0x58(%r14), %rdx
leaq 0x2a0392(%rip), %rdi    # 0x35e53b
leaq 0x2a0395(%rip), %rsi    # 0x35e545
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fbef
leaq 0x59(%r14), %rdx
leaq 0x2a0388(%rip), %rdi    # 0x35e565
leaq 0x2a0392(%rip), %rsi    # 0x35e576
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fbef
leaq 0x57(%r14), %rdx
leaq 0x2a038b(%rip), %rdi    # 0x35e597
leaq 0x2a038d(%rip), %rsi    # 0x35e5a0
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fbef
movq 0x68(%r14), %rdx
leaq 0x2fe857(%rip), %rdi    # 0x3bca97
leaq 0x2a0372(%rip), %rsi    # 0x35e5b9
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10cd10
movq 0x78(%r14), %rdx
leaq 0x2d17b4(%rip), %rdi    # 0x38fa28
leaq 0x2a035a(%rip), %rsi    # 0x35e5d5
callq 0x10f9f6
movq %rax, %r13
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r13, %rsi
callq 0x10cd10
leaq 0x10(%r14), %rdx
leaq 0x29d0c8(%rip), %rdi    # 0x35b369
leaq 0x29d0af(%rip), %rsi    # 0x35b357
movl $0x1, %r8d
xorl %ecx, %ecx
callq 0x10f7ed
movq %rax, %rbp
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x10cd10
leaq 0x55(%r14), %rdx
leaq 0x2957c2(%rip), %rdi    # 0x353a98
leaq 0x2a030c(%rip), %rsi    # 0x35e5e9
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r12
movq %rax, %rdi
callq 0x10fbef
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10cd10
leaq 0x56(%r14), %rdx
leaq 0x2a0305(%rip), %rdi    # 0x35e60a
leaq 0x2a0314(%rip), %rsi    # 0x35e620
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r15, %rdi
callq 0x10fbef
leaq 0x50(%r14), %rdx
leaq 0x2981b2(%rip), %rdi    # 0x3564e6
leaq 0x2a033a(%rip), %rsi    # 0x35e675
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
addq $0x51, %r14
movq %r14, %rdi
callq 0x10f473
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r13, %rdi
movq %rbp, %rsi
callq 0x10fd9f
movq %r13, %rdi
movq %r15, %rsi
callq 0x10fd9f
movq %r13, %rdi
movq %r12, %rsi
callq 0x10fd9f
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x10fd9f
movq %rbp, %rdi
movq %r12, %rsi
callq 0x10fd9f
movq 0x68(%rsp), %rdi
movq %r12, %rsi
callq 0x10fd9f
movq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x10fd9f
movq 0x48(%rsp), %r15
movq %r15, %rdi
movq 0x58(%rsp), %r14
movq %r14, %rsi
callq 0x10fd9f
movq 0x40(%rsp), %r12
movq %r12, %rdi
movq 0x38(%rsp), %r13
movq %r13, %rsi
callq 0x10fd9f
movq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x10fbff
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10fbff
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x10fbff
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x10fbff
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x10fbff
movq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x10fbff
movq 0x70(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10fc6f
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10fc6f
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10fc6f
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq