// File: /workspace/github_c_makefile_star2_O2/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 0x1e4f39(%rip), %rsi    # 0x348744
pushq $0x5e
popq %rdx
movl $0x150, %edi            # imm = 0x150
callq 0x93160
movq %rax, %r14
callq 0xae154
movq %rax, 0x10(%r14)
leaq 0x192049(%rip), %rdi    # 0x2f5874
callq 0xacbd1
movq %rax, 0x38(%r14)
andq $0x0, 0x30(%r14)
callq 0xacb84
movq %rax, 0x28(%r14)
xorl %r15d, %r15d
movb %r15b, 0x22(%r14)
andq $0x0, 0x8(%r14)
callq 0xacb84
movq %rax, 0x40(%r14)
movq $0x1, (%r14)
movb %r15b, 0x23(%r14)
andl $0x0, 0x1c(%r14)
andw $0x0, 0x20(%r14)
leaq 0x4(%r14), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%r14)
movups %xmm0, 0xa0(%r14)
andq $0x0, 0xc0(%r14)
movups %xmm0, 0xb0(%r14)
movups %xmm0, 0xd0(%r14)
movups %xmm0, 0xe0(%r14)
movups %xmm0, 0xf0(%r14)
andq $0x0, 0x100(%r14)
movl %ebp, 0x88(%r14)
leaq 0x1ac380(%rip), %rdi    # 0x30fc42
leaq 0x1e51c7(%rip), %rsi    # 0x348a90
pushq $0x1
popq %rbp
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x9abef
movq %rax, 0xb8(%r14)
movq %rax, %rdi
callq 0x9b488
movq 0xb8(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x48(%r14), %r15
leaq 0x6c(%r14), %rdx
leaq 0x1f2539(%rip), %rdi    # 0x355e3c
leaq 0x1e520f(%rip), %rsi    # 0x348b19
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x9abef
movq %rax, 0x108(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x108(%r14), %rdi
callq 0x9b10a
leaq 0x68(%r14), %rdx
leaq 0x1f383f(%rip), %rdi    # 0x35717c
leaq 0x1e51f6(%rip), %rsi    # 0x348b3a
pushq $0x4
popq %r8
xorl %ecx, %ecx
callq 0x9abef
movq %rax, 0x100(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x100(%r14), %rsi
movq 0x108(%r14), %rdi
callq 0x9b38d
leaq 0x74(%r14), %rdx
leaq 0x1f2887(%rip), %rdi    # 0x356206
leaq 0x1e51d3(%rip), %rsi    # 0x348b59
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0xc0(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0xc0(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x7c(%r14), %rdx
leaq 0x1e51cb(%rip), %rdi    # 0x348b81
leaq 0x1e51d4(%rip), %rsi    # 0x348b91
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0xc8(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0xc8(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x1e51c3(%rip), %rdi    # 0x348bac
leaq 0x1e51cf(%rip), %rsi    # 0x348bbf
pushq $0x1
popq %rcx
movq %r15, %rdx
callq 0x9a9e6
movq %rax, 0xe0(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0xe0(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
movq 0x10(%r14), %rdx
leaq 0x195b31(%rip), %rdi    # 0x2f9555
leaq 0x195b31(%rip), %rsi    # 0x2f955c
callq 0x9ad43
movq %rax, 0xe8(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0xe8(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x75(%r14), %rdx
leaq 0x1e51ab(%rip), %rdi    # 0x348c04
leaq 0x1e51b6(%rip), %rsi    # 0x348c16
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0xd8(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0xd8(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x192f6b(%rip), %rdi    # 0x2f69f7
leaq 0x1e51b7(%rip), %rsi    # 0x348c4a
movq %r14, %rdx
movl %ebp, %ecx
movl $0x3fffff, %r8d         # imm = 0x3FFFFF
callq 0x9ac01
movq %rax, 0xf0(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0xf0(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
cmpl $0x1, 0x88(%r14)
jne 0x163b4f
leaq 0x70(%r14), %rdx
leaq 0x1f6cc3(%rip), %rdi    # 0x35a79d
leaq 0x1e51ae(%rip), %rsi    # 0x348c8f
pushq $0x1
popq %r8
xorl %ecx, %ecx
callq 0x9abef
movq %rax, 0xd0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0xd0(%r14), %rdi
movq 0x100(%r14), %rsi
callq 0x9b38d
movq 0x40(%r14), %rdx
leaq 0x22140c(%rip), %rdi    # 0x384f28
leaq 0x186bfe(%rip), %rsi    # 0x2ea721
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, 0xf8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0xf0(%r14), %rsi
movq 0xf8(%r14), %rdi
callq 0x9b38d
leaq 0x76(%r14), %rdx
leaq 0x1e516a(%rip), %rdi    # 0x348cc4
leaq 0x1e516c(%rip), %rsi    # 0x348ccd
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x7b(%r14), %rdx
leaq 0x1e515c(%rip), %rdi    # 0x348ced
leaq 0x1e5170(%rip), %rsi    # 0x348d08
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x77(%r14), %rdx
leaq 0x1e5160(%rip), %rdi    # 0x348d28
leaq 0x1e5164(%rip), %rsi    # 0x348d33
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x78(%r14), %rdx
leaq 0x1e514c(%rip), %rdi    # 0x348d4b
leaq 0x1e5159(%rip), %rsi    # 0x348d5f
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x79(%r14), %rdx
leaq 0x1e5147(%rip), %rdi    # 0x348d7d
leaq 0x1e5156(%rip), %rsi    # 0x348d93
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x7a(%r14), %rdx
leaq 0x1e5155(%rip), %rdi    # 0x348dc2
leaq 0x1e5156(%rip), %rsi    # 0x348dca
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x7f(%r14), %rdx
leaq 0x1e5155(%rip), %rdi    # 0x348df9
leaq 0x1e515c(%rip), %rsi    # 0x348e07
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
movq %r14, %rdx
addq $0x7e, %rdx
leaq 0x1e514b(%rip), %rdi    # 0x348e29
leaq 0x1e5155(%rip), %rsi    # 0x348e3a
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x90(%r14)
movq %rax, %rdi
callq 0x9b10a
movq 0x90(%r14), %rsi
movq %rbx, %rdi
callq 0x97f31
leaq 0x9cf(%rip), %rsi       # 0x1646e0
movq %rbx, %rdi
movq %r14, %rdx
callq 0x980d4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq