// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x25bb8c
cmpl $0x0, 0xc(%rsp)
jne 0x25bbc4
movq 0x3e040d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ba476(%rip), %rsi    # 0x516013
leaq 0x31f3f8(%rip), %rdx    # 0x57af9c
leaq 0x31f41f(%rip), %rcx    # 0x57afca
leaq 0x31f09e(%rip), %r8     # 0x57ac50
movl $0x168, %r9d            # imm = 0x168
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x25bbc6
callq 0x25d030
movq %rax, (%rsp)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x88(%rax)
movq (%rsp), %rdx
addq $0x4, %rdx
leaq 0x2e5986(%rip), %rdi    # 0x541572
leaq 0x31f400(%rip), %rsi    # 0x57aff3
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0xf6510
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xb8(%rax)
movq (%rsp), %rax
movq 0xb8(%rax), %rdi
callq 0xf7450
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0xb8(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x24, %rdx
leaq 0x32cbf8(%rip), %rdi    # 0x58883e
leaq 0x31f42f(%rip), %rsi    # 0x57b07c
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0xf6510
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x108(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x108(%rax), %rsi
callq 0xf1600
movq (%rsp), %rax
movq 0x108(%rax), %rdi
callq 0xf7040
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x20, %rdx
leaq 0x32df07(%rip), %rdi    # 0x589ba7
leaq 0x31f3f6(%rip), %rsi    # 0x57b09d
xorl %ecx, %ecx
movl $0x4, %r8d
callq 0xf6510
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x100(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x100(%rax), %rsi
callq 0xf1600
movq (%rsp), %rax
movq 0x108(%rax), %rdi
movq (%rsp), %rax
movq 0x100(%rax), %rsi
callq 0xf7320
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x2c, %rdx
leaq 0x32cef6(%rip), %rdi    # 0x588bfb
leaq 0x31f3b0(%rip), %rsi    # 0x57b0bc
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xc0(%rax)
movq (%rsp), %rax
movq 0xc0(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0xc0(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x34, %rdx
leaq 0x31f38b(%rip), %rdi    # 0x57b0e4
leaq 0x31f394(%rip), %rsi    # 0x57b0f4
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xc8(%rax)
movq (%rsp), %rax
movq 0xc8(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0xc8(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
leaq 0x31f366(%rip), %rdi    # 0x57b10f
leaq 0x31f372(%rip), %rsi    # 0x57b122
movl $0x1, %ecx
callq 0xf5fe0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xe0(%rax)
movq (%rsp), %rax
movq 0xe0(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0xe0(%rax), %rsi
callq 0xf1600
movq (%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x2ce897(%rip), %rdi    # 0x52a693
leaq 0x2ce897(%rip), %rsi    # 0x52a69a
callq 0xf6a50
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xe8(%rax)
movq (%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0xe8(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x2d, %rdx
leaq 0x31f319(%rip), %rdi    # 0x57b167
leaq 0x31f324(%rip), %rsi    # 0x57b179
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xd8(%rax)
movq (%rsp), %rax
movq 0xd8(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0xd8(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
leaq 0x2cbc25(%rip), %rdi    # 0x527abf
leaq 0x31f30c(%rip), %rsi    # 0x57b1ad
movl $0x1, %ecx
movl $0x3fffff, %r8d         # imm = 0x3FFFFF
callq 0xf6570
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xf0(%rax)
movq (%rsp), %rax
movq 0xf0(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0xf0(%rax), %rsi
callq 0xf1600
movq (%rsp), %rax
cmpl $0x1, 0x88(%rax)
jne 0x25bfb7
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x28, %rdx
leaq 0x33144d(%rip), %rdi    # 0x58d355
leaq 0x31f2e3(%rip), %rsi    # 0x57b1f2
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0xf6510
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xd0(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0xd0(%rax), %rsi
callq 0xf1600
movq (%rsp), %rax
movq 0xd0(%rax), %rdi
movq (%rsp), %rax
movq 0x100(%rax), %rsi
callq 0xf7320
movq (%rsp), %rax
movq 0x40(%rax), %rdx
leaq 0x35e51f(%rip), %rdi    # 0x5ba488
leaq 0x2bf80a(%rip), %rsi    # 0x51b77a
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xf8(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0xf8(%rax), %rsi
callq 0xf1600
movq (%rsp), %rax
movq 0xf8(%rax), %rdi
movq (%rsp), %rax
movq 0xf0(%rax), %rsi
callq 0xf7320
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x2e, %rdx
leaq 0x31f25d(%rip), %rdi    # 0x57b227
leaq 0x31f25f(%rip), %rsi    # 0x57b230
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x33, %rdx
leaq 0x31f232(%rip), %rdi    # 0x57b250
leaq 0x31f246(%rip), %rsi    # 0x57b26b
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x2f, %rdx
leaq 0x31f219(%rip), %rdi    # 0x57b28b
leaq 0x31f21d(%rip), %rsi    # 0x57b296
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x30, %rdx
leaq 0x31f1e8(%rip), %rdi    # 0x57b2ae
leaq 0x31f1f5(%rip), %rsi    # 0x57b2c2
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x31, %rdx
leaq 0x31f1c6(%rip), %rdi    # 0x57b2e0
leaq 0x31f1d5(%rip), %rsi    # 0x57b2f6
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x32, %rdx
leaq 0x31f1b7(%rip), %rdi    # 0x57b325
leaq 0x31f1b8(%rip), %rsi    # 0x57b32d
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x37, %rdx
leaq 0x31f19a(%rip), %rdi    # 0x57b35c
leaq 0x31f1a1(%rip), %rsi    # 0x57b36a
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0xf1600
movq (%rsp), %rdx
addq $0x48, %rdx
addq $0x36, %rdx
leaq 0x31f176(%rip), %rdi    # 0x57b38c
leaq 0x31f180(%rip), %rsi    # 0x57b39d
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq 0x90(%rax), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0xf89(%rip), %rsi       # 0x25d1f0
callq 0xf1860
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)