// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_options.c
// Function: gt_encseq_options_register_generic
static GtEncseqOptions*
gt_encseq_options_register_generic(GtOptionParser *op,
                                   GtEncseqOptionsCreationStrategy strategy,
                                   GtStr *indexname,
                                   GtStrArray *inputdb)
{
  gt_assert(op != NULL && strategy != GT_ENCSEQ_OPTS_UNDEFINED);
  GtEncseqOptions *oi = gt_encseq_options_new();
  oi->withdb = (inputdb != NULL);
  oi->withindexname = (indexname != NULL);

  if (oi->withindexname) {
    gt_str_delete(oi->indexname);
    oi->indexname = gt_str_ref(indexname);
  }
  if (oi->withdb) {
    gt_str_array_delete(oi->db);
    oi->db = gt_str_array_ref(inputdb);
  }

  /* encoding options */
  if (strategy == GT_ENCSEQ_OPTS_ENCODE) {

    oi->optiontis = gt_option_new_bool("tis",
                                       "output transformed and encoded input "
                                       "sequence to file (deprecated, kept for "
                                       "compatibility reasons)",
                                       &oi->tis,
                                       true);
    gt_option_parser_add_option(op, oi->optiontis);
    gt_option_is_development_option(oi->optiontis);

    oi->optionssp = gt_option_new_bool("ssp",
                                       "output sequence separator positions "
                                       "to file",
                                       &oi->ssp,
                                       true);
    gt_option_parser_add_option(op, oi->optionssp);

    oi->optiondes = gt_option_new_bool("des",
                                       "output sequence descriptions to file",
                                       &oi->des,
                                       true);
    gt_option_parser_add_option(op, oi->optiondes);

    oi->optionsds = gt_option_new_bool("sds",
                                       "output sequence description separator "
                                       "positions to file",
                                       &oi->sds,
                                       true);
    gt_option_parser_add_option(op, oi->optionsds);
    gt_option_imply(oi->optionsds, oi->optiondes);

    oi->optionmd5 = gt_option_new_bool("md5",
                                       "output MD5 sums to file",
                                       &oi->md5,
                                       true);
    gt_option_parser_add_option(op, oi->optionmd5);

    oi->optionclip_desc = gt_option_new_bool("clipdesc",
                                             "clip descriptions after first "
                                             "whitespace",
                                             &oi->clip_desc,
                                             false);
    gt_option_parser_add_option(op, oi->optionclip_desc);

    oi->optionsat = gt_option_new_string("sat",
                                         "specify kind of sequence "
                                         "representation\n"
                                         "by one of the keywords direct, "
                                         "bytecompress, eqlen, bit, uchar, "
                                         "ushort, uint32",
                                         oi->sat, NULL);
    gt_option_parser_add_option(op, oi->optionsat);

    oi->optiondna = gt_option_new_bool("dna","input is DNA sequence",
                                       &oi->dna, false);
    gt_option_parser_add_option(op, oi->optiondna);

    oi->optionprotein = gt_option_new_bool("protein","input is "
                                           "protein sequence",
                                           &oi->protein, false);
    gt_option_parser_add_option(op, oi->optionprotein);

    oi->optionplain = gt_option_new_bool("plain","process as plain text",
                                         &oi->plain, false);
    gt_option_parser_add_option(op, oi->optionplain);
    gt_option_is_extended_option(oi->optionplain);

    oi->optiondust = gt_option_new_bool("dust","mask low-complexity regions "
                                               "using the dust algorithm",
                                         &oi->dust, false);
    gt_option_parser_add_option(op, oi->optiondust);

    oi->optiondust_echo = gt_option_new_bool("dustecho","echo the masked "
                                                       "sequence",
                                         &oi->dust_echo, false);
    gt_option_parser_add_option(op, oi->optiondust_echo);
    gt_option_imply(oi->optiondust_echo, oi->optiondust);
    gt_option_is_development_option(oi->optiondust_echo);

    oi->optiondust_windowsize = gt_option_new_ulong_min_max("dustwindow",
                                      "windowsize for the dust algorithm",
                                      &oi->dust_windowsize, 64, 3, 16777216);
    gt_option_parser_add_option(op, oi->optiondust_windowsize);
    gt_option_imply(oi->optiondust_windowsize, oi->optiondust);

    oi->optiondust_threshold = gt_option_new_double("dustthreshold","threshold "
                                                    "for the dust algorithm",
                                         &oi->dust_threshold, 2.0);
    gt_option_parser_add_option(op, oi->optiondust_threshold);
    gt_option_imply(oi->optiondust_threshold, oi->optiondust);

    oi->optiondust_linker = gt_option_new_ulong_min_max("dustlink","Max. "
                                              "distance between regions masked "
                                              "by dust before merging.",
                                         &oi->dust_linker, 1, 0, 16777216);
    gt_option_parser_add_option(op, oi->optiondust_linker);
    gt_option_imply(oi->optiondust_linker, oi->optiondust);

    oi->optiondb = gt_option_new_filename_array("db","specify database files",
                                                oi->db);

    oi->optionsmap = gt_option_new_string("smap",
                                          "specify file containing a "
                                          "symbol mapping",
                                          oi->smap, NULL);

    /* only add -indexname if not present already (e.g. suffixerator) */
    if (gt_option_parser_get_option(op, "indexname") == NULL) {
      oi->optionindexname = gt_option_new_string("indexname",
                                                 "specify name for index to "
                                                 "be generated",
                                                 oi->indexname, NULL);
      if (oi->withindexname) {
        gt_option_parser_add_option(op, oi->optionindexname);
      }
    }

    if (oi->withdb) {
      gt_option_parser_add_option(op, oi->optiondb);
    }

    gt_option_parser_add_option(op, oi->optionsmap);
    gt_option_exclude(oi->optionsmap, oi->optiondna);
    gt_option_exclude(oi->optionsmap, oi->optionprotein);
    gt_option_exclude(oi->optiondna, oi->optionprotein);
  }

  /* decoding options */
  if (strategy == GT_ENCSEQ_OPTS_LOAD) {
    oi->optionmirrored = gt_option_new_bool("mirrored", "virtually append the "
                                            "reverse complement of each "
                                            "sequence",
                                            &oi->mirrored,
                                            false);
    gt_option_parser_add_option(op, oi->optionmirrored);
  }

  /* only add -lossless if not present already (e.g. suffixerator) */
  if (gt_option_parser_get_option(op, "lossless") == NULL) {
    oi->optionlossless = gt_option_new_bool("lossless",
                                            "allow lossless original sequence "
                                            "retrieval",
                                            &oi->lossless,
                                            false);
    gt_option_parser_add_option(op, oi->optionlossless);
  }
  if (oi->optionlossless && oi->optiondust)
  {
    gt_option_exclude(oi->optionlossless, oi->optiondust);
  }

  gt_option_parser_register_hook(op, gt_encseq_options_check, oi);

  return oi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x33c30(%rip), %rsi     # 0x108919
movl $0xf8, %edi
movl $0x52, %edx
callq 0x35ee2
movq %rax, %r14
callq 0x3bfe0
movq %rax, (%r14)
callq 0x3bfe0
movq %rax, 0x8(%r14)
callq 0x3bfe0
movq %rax, 0x10(%r14)
callq 0x3bfe0
movq %rax, 0x18(%r14)
callq 0x3d23c
movq %rax, 0xc8(%r14)
xorl %eax, %eax
movw %ax, 0xdd(%r14)
movl %eax, 0xd0(%r14)
movb $0x0, 0xd4(%r14)
movl %eax, 0xd6(%r14)
movq $0x40, 0xe0(%r14)
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
movq %rcx, 0xf0(%r14)
movq $0x1, 0xe8(%r14)
movw %ax, 0xda(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x50(%r14)
movq %rax, 0x60(%r14)
movups %xmm0, 0x70(%r14)
movups %xmm0, 0x80(%r14)
movq %rax, 0x90(%r14)
movq %rax, 0xc0(%r14)
movups %xmm0, 0xb0(%r14)
movups %xmm0, 0xa0(%r14)
testq %r15, %r15
setne 0xda(%r14)
testq %r12, %r12
setne 0xdb(%r14)
je 0xd4dea
movq (%r14), %rdi
callq 0x3d1eb
movq %r12, %rdi
callq 0x3c561
movq %rax, (%r14)
cmpb $0x1, 0xda(%r14)
jne 0xd4e0f
movq 0xc8(%r14), %rdi
callq 0x3d573
movq %r15, %rdi
callq 0x3d26f
movq %rax, 0xc8(%r14)
cmpl $0x1, %ebp
je 0xd5272
testl %ebp, %ebp
jne 0xd52a0
leaq 0xd0(%r14), %r15
leaq 0xd6(%r14), %r13
leaq 0xdd(%r14), %r12
leaq 0xde(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0xe0(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0xf0(%r14), %rax
movq %rax, 0x18(%rsp)
leaq 0xe8(%r14), %rax
movq %rax, 0x20(%rsp)
leaq 0xd5(%r14), %rdx
leaq 0x3405c(%rip), %rdi     # 0x108ecf
leaq 0x34059(%rip), %rsi     # 0x108ed3
movl $0x1, %ecx
callq 0x39181
movq %rax, 0x58(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
movq 0x58(%r14), %rdi
callq 0x3991f
leaq 0xd1(%r14), %rdx
leaq 0x2cc40(%rip), %rdi     # 0x101aea
leaq 0x34085(%rip), %rsi     # 0x108f36
movl $0x1, %ecx
callq 0x39181
movq %rax, 0x38(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0x2cbd8(%rip), %rdi     # 0x101aa9
leaq 0x3408a(%rip), %rsi     # 0x108f62
movq %r15, %rdx
movl $0x1, %ecx
callq 0x39181
movq %rax, 0x40(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0xd2(%r14), %rdx
leaq 0x2cb9d(%rip), %rdi     # 0x101a9f
leaq 0x3407e(%rip), %rsi     # 0x108f87
movl $0x1, %ecx
callq 0x39181
movq %rax, 0x48(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdi
callq 0x3992f
leaq 0x34c5a(%rip), %rdi     # 0x109b90
leaq 0x34082(%rip), %rsi     # 0x108fbf
movq %r13, %rdx
movl $0x1, %ecx
callq 0x39181
movq %rax, 0x60(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0xdc(%r14), %rdx
leaq 0x34070(%rip), %rdi     # 0x108fd7
leaq 0x34072(%rip), %rsi     # 0x108fe0
xorl %ecx, %ecx
callq 0x39181
movq %rax, 0x98(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
movq 0x8(%r14), %rdx
leaq 0x2f757(%rip), %rdi     # 0x1046e9
leaq 0x34070(%rip), %rsi     # 0x109009
xorl %ecx, %ecx
callq 0x396b7
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0xd4(%r14), %rdx
leaq 0x20d8f(%rip), %rdi     # 0xf5d4c
leaq 0x340bc(%rip), %rsi     # 0x109080
xorl %ecx, %ecx
callq 0x39181
movq %rax, 0x70(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0xd7(%r14), %rdx
leaq 0x20c65(%rip), %rdi     # 0xf5c4d
leaq 0x340a7(%rip), %rsi     # 0x109096
xorl %ecx, %ecx
callq 0x39181
movq %rax, 0x80(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0xd8(%r14), %rdx
leaq 0x3409a(%rip), %rdi     # 0x1090b0
leaq 0x34099(%rip), %rsi     # 0x1090b6
xorl %ecx, %ecx
callq 0x39181
movq %rax, 0x78(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
movq 0x78(%r14), %rdi
callq 0x3990f
leaq 0x2f675(%rip), %rdi     # 0x1046b8
leaq 0x34082(%rip), %rsi     # 0x1090cc
movq %r12, %rdx
xorl %ecx, %ecx
callq 0x39181
movq %rax, 0xa0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0x34094(%rip), %rdi     # 0x109101
leaq 0x34096(%rip), %rsi     # 0x10910a
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x39181
movq %rax, 0xa8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdi
callq 0x3992f
movq 0xa8(%r14), %rdi
callq 0x3991f
leaq 0x3406b(%rip), %rdi     # 0x109123
leaq 0x3406f(%rip), %rsi     # 0x10912e
movl $0x40, %ecx
movl $0x3, %r8d
movl $0x1000000, %r9d        # imm = 0x1000000
movq 0x10(%rsp), %rdx
callq 0x39602
movq %rax, 0xb0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
movq 0xa0(%r14), %rsi
movq 0xb0(%r14), %rdi
callq 0x3992f
leaq 0x3404a(%rip), %rdi     # 0x109150
leaq 0x34051(%rip), %rsi     # 0x10915e
movsd 0x16dcb(%rip), %xmm0    # 0xebee0
movq 0x18(%rsp), %rdx
callq 0x39292
movq %rax, 0xb8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
movq 0xa0(%r14), %rsi
movq 0xb8(%r14), %rdi
callq 0x3992f
leaq 0x34034(%rip), %rdi     # 0x10917f
leaq 0x34036(%rip), %rsi     # 0x109188
movl $0x1, %ecx
movl $0x1000000, %r9d        # imm = 0x1000000
movq 0x20(%rsp), %rdx
xorl %r8d, %r8d
callq 0x39602
movq %rax, 0xc0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
movq 0xa0(%r14), %rsi
movq 0xc0(%r14), %rdi
callq 0x3992f
movq 0xc8(%r14), %rdx
leaq 0x1ddbd(%rip), %rdi     # 0xf2f5a
leaq 0x34021(%rip), %rsi     # 0x1091c5
callq 0x39726
movq %rax, 0x20(%r14)
movq 0x10(%r14), %rdx
leaq 0x2f59d(%rip), %rdi     # 0x104755
leaq 0x3401d(%rip), %rsi     # 0x1091dc
xorl %ecx, %ecx
callq 0x396b7
movq %rax, 0x88(%r14)
leaq 0x2f8f9(%rip), %rsi     # 0x104acd
movq %rbx, %rdi
callq 0x36a94
testq %rax, %rax
jne 0xd5212
movq (%r14), %rdx
leaq 0x2f8e2(%rip), %rdi     # 0x104acd
leaq 0x34013(%rip), %rsi     # 0x109205
xorl %ecx, %ecx
callq 0x396b7
movq %rax, 0x28(%r14)
cmpb $0x1, 0xdb(%r14)
jne 0xd5212
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
cmpb $0x1, 0xda(%r14)
jne 0xd522b
leaq 0x20(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x36a40
movq 0x88(%r14), %rsi
movq %rbx, %rdi
callq 0x36a40
movq 0x70(%r14), %rsi
movq 0x88(%r14), %rdi
callq 0x39acf
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdi
callq 0x39acf
movq 0x70(%r14), %rdi
movq 0x80(%r14), %rsi
callq 0x39acf
cmpl $0x1, %ebp
jne 0xd52a0
leaq 0xd9(%r14), %rdx
leaq 0x28652(%rip), %rdi     # 0xfd8d2
leaq 0x33fa5(%rip), %rsi     # 0x10922c
xorl %ecx, %ecx
callq 0x39181
movq %rax, 0x90(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
leaq 0x33fbe(%rip), %rsi     # 0x109265
movq %rbx, %rdi
callq 0x36a94
testq %rax, %rax
jne 0xd52df
leaq 0xd3(%r14), %rdx
leaq 0x33fa3(%rip), %rdi     # 0x109265
leaq 0x33fa5(%rip), %rsi     # 0x10926e
xorl %ecx, %ecx
callq 0x39181
movq %rax, 0x50(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x36a40
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0xd52fe
movq %r14, %rax
addq $0xa0, %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xd52fe
callq 0x39acf
leaq 0x3b6(%rip), %rsi       # 0xd56bb
movq %rbx, %rdi
movq %r14, %rdx
callq 0x36ae6
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq