// File: /workspace/github_c_makefile_star2_O3/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 0x296530(%rip), %rdi    # 0x35229e
leaq 0x299262(%rip), %rsi    # 0x354fd7
callq 0x107bfe
movq %rax, %rbx
leaq 0x28a548(%rip), %rsi    # 0x3462cc
movq %rax, %rdi
callq 0x107e5c
leaq 0x2cbdea(%rip), %rdi    # 0x387b7d
leaq 0x299267(%rip), %rsi    # 0x355001
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10a4fd
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x107bec
movq %rax, 0x90(%r14)
leaq 0x52(%r14), %rdx
leaq 0x2a13f8(%rip), %rdi    # 0x35d1c4
leaq 0x299250(%rip), %rsi    # 0x355023
movl $0x1, %ecx
callq 0x10a235
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x107bec
movq %rax, 0x80(%r14)
leaq 0x53(%r14), %rdx
leaq 0x29f050(%rip), %rdi    # 0x35ae55
leaq 0x29922f(%rip), %rsi    # 0x35503b
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x68(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x54(%r14), %rdx
leaq 0x2d99a7(%rip), %rdi    # 0x3957d5
leaq 0x29921e(%rip), %rsi    # 0x355053
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x4(%r14), %rdx
leaq 0x2e3db1(%rip), %rdi    # 0x39fc08
leaq 0x299217(%rip), %rsi    # 0x355075
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10a51f
movq %rax, %r15
movq %rax, 0x70(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x107bec
movq %rax, 0x88(%r14)
leaq 0x20(%r14), %rdx
leaq 0x2991fc(%rip), %rdi    # 0x355094
leaq 0x2991fd(%rip), %rsi    # 0x35509c
movl $0x2, %r8d
xorl %ecx, %ecx
callq 0x10a5d1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x18(%r14), %rdx
leaq 0x299223(%rip), %rdi    # 0x3550e5
leaq 0x299228(%rip), %rsi    # 0x3550f1
movl $0x61, %ecx
movl $0x5a, %r8d
movl $0x64, %r9d
callq 0x10a5ff
movq %rax, %r15
movq %rax, 0x58(%rsp)
movq %rax, %rdi
callq 0x10ac2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x107bec
movq %rax, 0x98(%r14)
leaq 0x8(%r14), %rdx
leaq 0x299237(%rip), %rdi    # 0x35514b
leaq 0x29923b(%rip), %rsi    # 0x355156
xorl %ecx, %ecx
callq 0x10a5ad
movq %rax, 0x50(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x48(%r14), %rdx
leaq 0x2992a8(%rip), %rdi    # 0x3551e5
leaq 0x2992ae(%rip), %rsi    # 0x3551f2
movl $0x61, %ecx
movl $0x5a, %r8d
movl $0x64, %r9d
callq 0x10a5ff
movq %rax, %r15
movq %rax, 0x48(%rsp)
movq %rax, %rdi
callq 0x10ac2f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x107bec
movq %rax, 0xa0(%r14)
leaq 0x38(%r14), %r15
leaq 0x2ca4b5(%rip), %rdi    # 0x386444
leaq 0x2992ce(%rip), %rsi    # 0x355264
movl $0xa, %ecx
movl $0x1, %r8d
movl $0x1e, %r9d
movq %r15, %rdx
callq 0x10a5ff
movq %rax, %r12
movq %rax, 0x40(%rsp)
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107cc0
leaq 0x2eef2d(%rip), %rdi    # 0x3aaefe
leaq 0x29932c(%rip), %rsi    # 0x355304
movl $0x50, %ecx
movl $0x46, %r8d
movl $0x63, %r9d
movq %r15, %rdx
callq 0x10a5ff
movq %rax, 0x38(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x40(%r14), %rdx
leaq 0x299363(%rip), %rdi    # 0x35536f
leaq 0x29936a(%rip), %rsi    # 0x35537d
xorl %ecx, %ecx
callq 0x10a2ab
movq %rax, %r15
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a9d4
leaq 0x28(%r14), %rdx
leaq 0x299462(%rip), %rdi    # 0x3554a2
leaq 0x2993e1(%rip), %rsi    # 0x355428
movl $0x3c, %ecx
movl $0x40, %r9d
xorl %r8d, %r8d
callq 0x10a5ff
movq %rax, %r15
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a9d4
leaq 0x30(%r14), %rdx
leaq 0x2993f1(%rip), %rdi    # 0x355471
leaq 0x2993f9(%rip), %rsi    # 0x355480
movl $0x1, %r8d
movl $0x64, %r9d
xorl %ecx, %ecx
callq 0x10a5ff
movq %rax, %r15
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a9d4
movq 0x60(%r14), %rdx
leaq 0x2f73b3(%rip), %rdi    # 0x3b3473
leaq 0x2962bb(%rip), %rsi    # 0x352382
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a87b
callq 0x1e0655
movq 0x70(%r14), %rdx
leaq 0x2993b6(%rip), %rdi    # 0x3554aa
leaq 0x2993b3(%rip), %rcx    # 0x3554ae
movq %rax, %rsi
callq 0x10a770
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a9d4
callq 0x1b9e20
movq 0xb0(%r14), %rdx
leaq 0x2ef262(%rip), %rdi    # 0x3ab38e
movq %rax, %rsi
callq 0x10a7a1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0xb8(%r14), %rdx
leaq 0x2bbb40(%rip), %rdi    # 0x377c8d
leaq 0x299362(%rip), %rsi    # 0x3554b6
movsd 0x298e44(%rip), %xmm0   # 0x354fa0
callq 0x10a346
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10ac2f
movq %r15, %rdi
callq 0x107bec
movq %rax, 0xa8(%r14)
leaq 0x58(%r14), %rdx
leaq 0x29937a(%rip), %rdi    # 0x35550b
leaq 0x29937d(%rip), %rsi    # 0x355515
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a9d4
leaq 0x59(%r14), %rdx
leaq 0x299370(%rip), %rdi    # 0x355535
leaq 0x29937a(%rip), %rsi    # 0x355546
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a9d4
leaq 0x57(%r14), %rdx
leaq 0x299373(%rip), %rdi    # 0x355567
leaq 0x299375(%rip), %rsi    # 0x355570
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a9d4
movq 0x68(%r14), %rdx
leaq 0x2f724f(%rip), %rdi    # 0x3b3477
leaq 0x29935a(%rip), %rsi    # 0x355589
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, 0x8(%rsp)
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r15, %rsi
callq 0x107cc0
movq 0x78(%r14), %rdx
leaq 0x2ca3ec(%rip), %rdi    # 0x386648
leaq 0x299342(%rip), %rsi    # 0x3555a5
callq 0x10a7df
movq %rax, %r13
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r13, %rsi
callq 0x107cc0
leaq 0x10(%r14), %rdx
leaq 0x2960a8(%rip), %rdi    # 0x352331
leaq 0x29608f(%rip), %rsi    # 0x35231f
movl $0x1, %r8d
xorl %ecx, %ecx
callq 0x10a5d1
movq %rax, %rbp
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x107cc0
leaq 0x55(%r14), %rdx
leaq 0x28e7b9(%rip), %rdi    # 0x34aa77
leaq 0x2992f4(%rip), %rsi    # 0x3555b9
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r12
movq %rax, %rdi
callq 0x10a9d4
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107cc0
leaq 0x56(%r14), %rdx
leaq 0x2992ed(%rip), %rdi    # 0x3555da
leaq 0x2992fc(%rip), %rsi    # 0x3555f0
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x10a9d4
leaq 0x50(%r14), %rdx
leaq 0x29119a(%rip), %rdi    # 0x34d4b6
leaq 0x299322(%rip), %rsi    # 0x355645
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
addq $0x51, %r14
movq %r14, %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r13, %rdi
movq %rbp, %rsi
callq 0x10ab96
movq %r13, %rdi
movq %r15, %rsi
callq 0x10ab96
movq %r13, %rdi
movq %r12, %rsi
callq 0x10ab96
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x10ab96
movq %rbp, %rdi
movq %r12, %rsi
callq 0x10ab96
movq 0x68(%rsp), %rdi
movq %r12, %rsi
callq 0x10ab96
movq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x10ab96
movq 0x48(%rsp), %r15
movq %r15, %rdi
movq 0x58(%rsp), %r14
movq %r14, %rsi
callq 0x10ab96
movq 0x40(%rsp), %r12
movq %r12, %rdi
movq 0x38(%rsp), %r13
movq %r13, %rsi
callq 0x10ab96
movq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x10a9e4
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10a9e4
movq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x10a9e4
movq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x10a9e4
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x10a9e4
movq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x10a9e4
movq 0x70(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10aa54
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10aa54
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x10aa54
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq