// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/index_options.c
// Function: gt_index_options_register_generic_create
static GtIndexOptions* gt_index_options_register_generic_create(
                                                      GtOptionParser *op,
                                                      GtIndexOptionsIndexType t)
{
  GtIndexOptions *idxo;
  gt_assert(op != NULL && t != GT_INDEX_OPTIONS_UNDEFINED);
  idxo = gt_index_options_new();
  idxo->type = t;
  idxo->optionprefixlength = gt_option_new_uint_min("pl",
                                    "specify prefix length for bucket sort\n"
                                    "recommendation: use without argument;\n"
                                    "then a reasonable prefix length is "
                                    "automatically determined.",
                                    &idxo->prefixlength,
                                    GT_PREFIXLENGTH_AUTOMATIC,
                                    1U);
  gt_option_argument_is_optional(idxo->optionprefixlength);
  gt_option_parser_add_option(op, idxo->optionprefixlength);

  idxo->optionuserdefinedsortmaxdepth
    = gt_option_new_uint_min("sortmaxdepth","sort only up to the given depth.",
                             &idxo->sfxstrategy.userdefinedsortmaxdepth,
                             0,
                             1U);
  gt_option_parser_add_option(op, idxo->optionuserdefinedsortmaxdepth);
  gt_option_is_development_option(idxo->optionuserdefinedsortmaxdepth);

  idxo->optiondifferencecover = gt_option_new_uint_min("dc",
                                    "specify difference cover value",
                                    &idxo->sfxstrategy.differencecover,
                                    0,
                                    4U);
  gt_option_parser_add_option(op, idxo->optiondifferencecover);
  gt_option_exclude(idxo->optionuserdefinedsortmaxdepth,
                    idxo->optiondifferencecover);

  idxo->optioncmpcharbychar = gt_option_new_bool("cmpcharbychar",
                                           "compare suffixes character "
                                           "by character",
                                           &idxo->sfxstrategy.cmpcharbychar,
                                           false);
  gt_option_is_development_option(idxo->optioncmpcharbychar);
  gt_option_parser_add_option(op, idxo->optioncmpcharbychar);

  idxo->optionnoshortreadsort = gt_option_new_bool("noshortreadsort",
                                           "do not use short read sort",
                                           &idxo->sfxstrategy.noshortreadsort,
                                           false);
  gt_option_is_development_option(idxo->optionnoshortreadsort);
  gt_option_parser_add_option(op, idxo->optionnoshortreadsort);

  idxo->optionmaxwidthrealmedian = gt_option_new_uword("maxwidthrealmedian",
                                                 "compute real median for "
                                                 "intervals of at most the "
                                                 "given widthprefixes",
                                                 &idxo->sfxstrategy.
                                                      maxwidthrealmedian,
                                                 1UL);
  gt_option_is_development_option(idxo->optionmaxwidthrealmedian);
  gt_option_parser_add_option(op, idxo->optionmaxwidthrealmedian);

  idxo->optionalgbounds
    = gt_option_new_string_array("algbds",
                                 "length boundaries for the different "
                                 "algorithms to sort buckets of suffixes\n"
                                 "first number: maxbound for insertion sort\n"
                                 "second number: maxbound for blindtrie sort\n"
                                 "third number: maxbound for counting sort",
                                 idxo->algbounds);
  gt_option_is_development_option(idxo->optionalgbounds);
  gt_option_parser_add_option(op, idxo->optionalgbounds);

  idxo->optionstorespecialcodes
    = gt_option_new_bool("storespecialcodes",
                         "store special codes (this may speed up the program)",
                         &idxo->sfxstrategy.storespecialcodes,false);

  gt_option_is_development_option(idxo->optionstorespecialcodes);
  gt_option_parser_add_option(op, idxo->optionstorespecialcodes);

  idxo->optionparts
    = gt_option_new_uint_max("parts",
                             "specify number of parts in which the index "
                             "construction is performed",
                             &idxo->numofparts, 1U, (unsigned) ((1 << 22) - 1));
  gt_option_is_development_option(idxo->optionparts);
  gt_option_parser_add_option(op, idxo->optionparts);

  if (idxo->type == GT_INDEX_OPTIONS_ESA)
  {
    idxo->optionspmopt = gt_option_new_uint_min("spmopt",
                                            "optimize esa-construction for "
                                            "suffix-prefix matching",
                                            &idxo->sfxstrategy.spmopt_minlength,
                                            0,1U);
    gt_option_parser_add_option(op, idxo->optionspmopt);
    gt_option_exclude(idxo->optionspmopt, idxo->optiondifferencecover);
    idxo->optionmemlimit = gt_option_new_string("memlimit",
                           "specify maximal amount of memory to be used during "
                           "index construction (in bytes, the keywords 'MB' "
                           "and 'GB' are allowed)",
                           idxo->memlimit, NULL);
    gt_option_parser_add_option(op, idxo->optionmemlimit);
    gt_option_exclude(idxo->optionmemlimit, idxo->optionparts);
  }

  idxo->option = gt_option_new_bool("iterscan",
                                   "use iteratorbased-kmer scanning",
                                   &idxo->sfxstrategy.iteratorbasedkmerscanning,
                                   false);
  gt_option_is_development_option(idxo->option);
  gt_option_parser_add_option(op, idxo->option);

  idxo->option = gt_option_new_bool("samplewithprefixlengthnull",
                                  "sort sample with prefixlength=0",
                                  &idxo->sfxstrategy.samplewithprefixlengthnull,
                                  false);
  gt_option_is_development_option(idxo->option);
  gt_option_parser_add_option(op, idxo->option);

  idxo->option = gt_option_new_bool("suftabuint",
                                    "use uint32_t for suftab",
                                    &idxo->sfxstrategy.suftabuint,
                                    false);
  gt_option_is_development_option(idxo->option);
  gt_option_parser_add_option(op, idxo->option);

  idxo->option = gt_option_new_bool("onlybucketinsertion",
                                    "perform only bucket insertion",
                                    &idxo->sfxstrategy.onlybucketinsertion,
                                    false);
  gt_option_is_development_option(idxo->option);
  gt_option_parser_add_option(op, idxo->option);

  idxo->option = gt_option_new_bool("kmerswithencseqreader",
                               "always perform kmerscanning with encseq-reader",
                               &idxo->sfxstrategy.kmerswithencseqreader,
                               false);
  gt_option_is_development_option(idxo->option);
  gt_option_parser_add_option(op, idxo->option);

  idxo->option = gt_option_new_bool("dccheck",
                               "check intermediate results in difference cover",
                               &idxo->sfxstrategy.dccheck,
                               false);
  gt_option_is_development_option(idxo->option);
  gt_option_parser_add_option(op, idxo->option);

  idxo->option = gt_option_new_bool("withradixsort",
                                    "use radixsort to sort the buckets",
                                    &idxo->sfxstrategy.withradixsort,
                                    false);
  gt_option_is_development_option(idxo->option);
  gt_option_parser_add_option(op, idxo->option);

  idxo->option = gt_option_new_bool("compressedoutput",
                                    "output suftab and lcptab in compressed "
                                    "form",
                                    &idxo->sfxstrategy.compressedoutput,
                                    false);
  gt_option_is_development_option(idxo->option);
  gt_option_parser_add_option(op, idxo->option);

  gt_option_parser_register_hook(op, gt_index_options_check_set_create_opts,
                                 idxo);
  return idxo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x1f2cf3(%rip), %rsi    # 0x3a83b1
movl $0x150, %edi            # imm = 0x150
movl $0x5e, %edx
callq 0x104226
movq %rax, %r14
callq 0x11be10
movq %rax, 0x10(%r14)
leaq 0x1a0184(%rip), %rdi    # 0x355864
callq 0x11acc9
movq %rax, 0x38(%r14)
xorl %r15d, %r15d
movq %r15, 0x30(%r14)
callq 0x11ac6c
movq %rax, 0x28(%r14)
movb %r15b, 0x22(%r14)
movq %r15, 0x8(%r14)
callq 0x11ac6c
movq %rax, 0x40(%r14)
movq $0x1, (%r14)
leaq 0x4(%r14), %rdx
movb %r15b, 0x23(%r14)
movl $0x0, 0x1c(%r14)
movw $0x0, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%r14)
movups %xmm0, 0xa0(%r14)
movups %xmm0, 0xb0(%r14)
movq %r15, 0xc0(%r14)
movups %xmm0, 0xd0(%r14)
movups %xmm0, 0xe0(%r14)
movups %xmm0, 0xf0(%r14)
movq %r15, 0x100(%r14)
movl %ebp, 0x88(%r14)
leaq 0x1ba1bb(%rip), %rdi    # 0x36f932
leaq 0x1f2f7f(%rip), %rsi    # 0x3a86fd
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10a51f
movq %rax, 0xb8(%r14)
movq %rax, %rdi
callq 0x10ac2f
movq 0xb8(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x48(%r14), %r15
leaq 0x6c(%r14), %rdx
leaq 0x200224(%rip), %rdi    # 0x3b59dc
leaq 0x1f2fc7(%rip), %rsi    # 0x3a8786
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10a51f
movq %rax, 0x108(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x108(%r14), %rdi
callq 0x10a9d4
leaq 0x68(%r14), %rdx
leaq 0x201527(%rip), %rdi    # 0x3b6d1c
leaq 0x1f2fab(%rip), %rsi    # 0x3a87a7
xorl %ecx, %ecx
movl $0x4, %r8d
callq 0x10a51f
movq %rax, 0x100(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x100(%r14), %rsi
movq 0x108(%r14), %rdi
callq 0x10ab96
leaq 0x74(%r14), %rdx
leaq 0x20056d(%rip), %rdi    # 0x3b5da6
leaq 0x1f2f86(%rip), %rsi    # 0x3a87c6
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0xc0(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0xc0(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x7c(%r14), %rdx
leaq 0x1f2f7e(%rip), %rdi    # 0x3a87ee
leaq 0x1f2f87(%rip), %rsi    # 0x3a87fe
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0xc8(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0xc8(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x1f2f76(%rip), %rdi    # 0x3a8819
leaq 0x1f2f82(%rip), %rsi    # 0x3a882c
movl $0x1, %ecx
movq %r15, %rdx
callq 0x10a2ab
movq %rax, 0xe0(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0xe0(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
movq 0x10(%r14), %rdx
leaq 0x1a3c9d(%rip), %rdi    # 0x35957d
leaq 0x1a3c9d(%rip), %rsi    # 0x359584
callq 0x10a7a1
movq %rax, 0xe8(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0xe8(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x75(%r14), %rdx
leaq 0x1f2f5c(%rip), %rdi    # 0x3a8871
leaq 0x1f2f67(%rip), %rsi    # 0x3a8883
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0xd8(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0xd8(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x1a109f(%rip), %rdi    # 0x3569e7
leaq 0x1f2f68(%rip), %rsi    # 0x3a88b7
movq %r14, %rdx
movl $0x1, %ecx
movl $0x3fffff, %r8d         # imm = 0x3FFFFF
callq 0x10a548
movq %rax, 0xf0(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0xf0(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
cmpl $0x1, 0x88(%r14)
jne 0x1b5a10
leaq 0x70(%r14), %rdx
leaq 0x2049a4(%rip), %rdi    # 0x3ba33d
leaq 0x1f2f5c(%rip), %rsi    # 0x3a88fc
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10a51f
movq %rax, 0xd0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0xd0(%r14), %rdi
movq 0x100(%r14), %rsi
callq 0x10ab96
movq 0x40(%r14), %rdx
leaq 0x22f16b(%rip), %rdi    # 0x3e4b48
leaq 0x194d3d(%rip), %rsi    # 0x34a721
xorl %ecx, %ecx
callq 0x10a770
movq %rax, 0xf8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0xf0(%r14), %rsi
movq 0xf8(%r14), %rdi
callq 0x10ab96
leaq 0x76(%r14), %rdx
leaq 0x1f2f16(%rip), %rdi    # 0x3a8931
leaq 0x1f2f18(%rip), %rsi    # 0x3a893a
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x7b(%r14), %rdx
leaq 0x1f2f08(%rip), %rdi    # 0x3a895a
leaq 0x1f2f1c(%rip), %rsi    # 0x3a8975
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x77(%r14), %rdx
leaq 0x1f2f0c(%rip), %rdi    # 0x3a8995
leaq 0x1f2f10(%rip), %rsi    # 0x3a89a0
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x78(%r14), %rdx
leaq 0x1f2ef8(%rip), %rdi    # 0x3a89b8
leaq 0x1f2f05(%rip), %rsi    # 0x3a89cc
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x79(%r14), %rdx
leaq 0x1f2ef3(%rip), %rdi    # 0x3a89ea
leaq 0x1f2f02(%rip), %rsi    # 0x3a8a00
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x7a(%r14), %rdx
leaq 0x1f2f01(%rip), %rdi    # 0x3a8a2f
leaq 0x1f2f02(%rip), %rsi    # 0x3a8a37
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x7f(%r14), %rdx
leaq 0x1f2f01(%rip), %rdi    # 0x3a8a66
leaq 0x1f2f08(%rip), %rsi    # 0x3a8a74
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
movq %r14, %rdx
addq $0x7e, %rdx
leaq 0x1f2ef7(%rip), %rdi    # 0x3a8a96
leaq 0x1f2f01(%rip), %rsi    # 0x3a8aa7
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10a9d4
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x107cc0
leaq 0x4b7(%rip), %rsi       # 0x1b6089
movq %rbx, %rdi
movq %r14, %rdx
callq 0x107d66
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq