// File: /workspace/github_c_makefile_star2_O1/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 0x1f3863(%rip), %rsi    # 0x3b196d
movl $0x150, %edi            # imm = 0x150
movl $0x5e, %edx
callq 0x1092b2
movq %rax, %r14
callq 0x121b54
movq %rax, 0x10(%r14)
leaq 0x20bfca(%rip), %rdi    # 0x3ca0f6
callq 0x120955
movq %rax, 0x38(%r14)
xorl %r15d, %r15d
movq %r15, 0x30(%r14)
callq 0x1208f8
movq %rax, 0x28(%r14)
movb %r15b, 0x22(%r14)
movq %r15, 0x8(%r14)
callq 0x1208f8
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 0x1ba9df(%rip), %rdi    # 0x378ba2
leaq 0x1f3aef(%rip), %rsi    # 0x3b1cb9
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10f73b
movq %rax, 0xb8(%r14)
movq %rax, %rdi
callq 0x10fe42
movq 0xb8(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x48(%r14), %r15
leaq 0x6c(%r14), %rdx
leaq 0x200df8(%rip), %rdi    # 0x3beffc
leaq 0x1f3b37(%rip), %rsi    # 0x3b1d42
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10f73b
movq %rax, 0x108(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x108(%r14), %rdi
callq 0x10fbef
leaq 0x68(%r14), %rdx
leaq 0x2020fb(%rip), %rdi    # 0x3c033c
leaq 0x1f3b1b(%rip), %rsi    # 0x3b1d63
xorl %ecx, %ecx
movl $0x4, %r8d
callq 0x10f73b
movq %rax, 0x100(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x100(%r14), %rsi
movq 0x108(%r14), %rdi
callq 0x10fd9f
leaq 0x74(%r14), %rdx
leaq 0x201141(%rip), %rdi    # 0x3bf3c6
leaq 0x1f3af6(%rip), %rsi    # 0x3b1d82
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0xc0(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0xc0(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x7c(%r14), %rdx
leaq 0x1f3aee(%rip), %rdi    # 0x3b1daa
leaq 0x1f3af7(%rip), %rsi    # 0x3b1dba
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0xc8(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0xc8(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x1f3ae6(%rip), %rdi    # 0x3b1dd5
leaq 0x1f3af2(%rip), %rsi    # 0x3b1de8
movl $0x1, %ecx
movq %r15, %rdx
callq 0x10f4c7
movq %rax, 0xe0(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0xe0(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
movq 0x10(%r14), %rdx
leaq 0x1a42a1(%rip), %rdi    # 0x3625cd
leaq 0x1a42a1(%rip), %rsi    # 0x3625d4
callq 0x10f9b8
movq %rax, 0xe8(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0xe8(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x75(%r14), %rdx
leaq 0x1f3acc(%rip), %rdi    # 0x3b1e2d
leaq 0x1f3ad7(%rip), %rsi    # 0x3b1e3f
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0xd8(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0xd8(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x1a1683(%rip), %rdi    # 0x35fa17
leaq 0x1f3ad8(%rip), %rsi    # 0x3b1e73
movq %r14, %rdx
movl $0x1, %ecx
movl $0x3fffff, %r8d         # imm = 0x3FFFFF
callq 0x10f764
movq %rax, 0xf0(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0xf0(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
cmpl $0x1, 0x88(%r14)
jne 0x1be45c
leaq 0x70(%r14), %rdx
leaq 0x2055c8(%rip), %rdi    # 0x3c39ad
leaq 0x1f3acc(%rip), %rsi    # 0x3b1eb8
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x10f73b
movq %rax, 0xd0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0xd0(%r14), %rdi
movq 0x100(%r14), %rsi
callq 0x10fd9f
movq 0x40(%r14), %rdx
leaq 0x22fee3(%rip), %rdi    # 0x3ee30c
leaq 0x195312(%rip), %rsi    # 0x353742
xorl %ecx, %ecx
callq 0x10f987
movq %rax, 0xf8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0xf0(%r14), %rsi
movq 0xf8(%r14), %rdi
callq 0x10fd9f
leaq 0x76(%r14), %rdx
leaq 0x1f3a86(%rip), %rdi    # 0x3b1eed
leaq 0x1f3a88(%rip), %rsi    # 0x3b1ef6
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x7b(%r14), %rdx
leaq 0x1f3a78(%rip), %rdi    # 0x3b1f16
leaq 0x1f3a8c(%rip), %rsi    # 0x3b1f31
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x77(%r14), %rdx
leaq 0x1f3a7c(%rip), %rdi    # 0x3b1f51
leaq 0x1f3a80(%rip), %rsi    # 0x3b1f5c
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x78(%r14), %rdx
leaq 0x1f3a68(%rip), %rdi    # 0x3b1f74
leaq 0x1f3a75(%rip), %rsi    # 0x3b1f88
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x79(%r14), %rdx
leaq 0x1f3a63(%rip), %rdi    # 0x3b1fa6
leaq 0x1f3a72(%rip), %rsi    # 0x3b1fbc
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x7a(%r14), %rdx
leaq 0x1f3a71(%rip), %rdi    # 0x3b1feb
leaq 0x1f3a72(%rip), %rsi    # 0x3b1ff3
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x7f(%r14), %rdx
leaq 0x1f3a71(%rip), %rdi    # 0x3b2022
leaq 0x1f3a78(%rip), %rsi    # 0x3b2030
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
movq %r14, %rdx
addq $0x7e, %rdx
leaq 0x1f3a67(%rip), %rdi    # 0x3b2052
leaq 0x1f3a71(%rip), %rsi    # 0x3b2063
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x10fbef
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x10cd10
leaq 0x4b7(%rip), %rsi       # 0x1bead5
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10cdb6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq