// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x332f0(%rip), %rsi     # 0x108741
movl $0xf8, %edi
movl $0x52, %edx
callq 0x35862
movq %rax, %r14
callq 0x3b728
movq %rax, (%r14)
callq 0x3b728
movq %rax, 0x8(%r14)
callq 0x3b728
movq %rax, 0x10(%r14)
callq 0x3b728
movq %rax, 0x18(%r14)
callq 0x3c8cc
movq %rax, 0xc8(%r14)
movw $0x0, 0xdd(%r14)
xorl %eax, %eax
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)
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 0xd59cc
movq (%r14), %rdi
callq 0x3c87b
movq %r12, %rdi
callq 0x3bcaf
movq %rax, (%r14)
testb $0x1, 0xda(%r14)
je 0xd5575
movq 0xc8(%r14), %rdi
callq 0x3cc00
movq %r15, %rdi
callq 0x3c8ff
movq %rax, 0xc8(%r14)
cmpl $0x1, %ebp
je 0xd59da
testl %ebp, %ebp
jne 0xd5a08
leaq 0xd0(%r14), %r13
leaq 0xd6(%r14), %r12
leaq 0xdd(%r14), %r15
leaq 0xde(%r14), %rbp
leaq 0xe0(%r14), %rax
movq %rax, (%rsp)
leaq 0xf0(%r14), %rax
movq %rax, 0x8(%rsp)
leaq 0xe8(%r14), %rax
movq %rax, 0x10(%rsp)
leaq 0xd5(%r14), %rdx
leaq 0x33724(%rip), %rdi     # 0x108cf7
leaq 0x33721(%rip), %rsi     # 0x108cfb
movl $0x1, %ecx
callq 0x3893d
movq %rax, 0x58(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
movq 0x58(%r14), %rdi
callq 0x390dc
leaq 0xd1(%r14), %rdx
leaq 0x2c454(%rip), %rdi     # 0x101a5e
leaq 0x3374d(%rip), %rsi     # 0x108d5e
movl $0x1, %ecx
callq 0x3893d
movq %rax, 0x38(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0x2c3ec(%rip), %rdi     # 0x101a1d
leaq 0x33752(%rip), %rsi     # 0x108d8a
movq %r13, %rdx
movl $0x1, %ecx
callq 0x3893d
movq %rax, 0x40(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0xd2(%r14), %rdx
leaq 0x2c3b1(%rip), %rdi     # 0x101a13
leaq 0x33746(%rip), %rsi     # 0x108daf
movl $0x1, %ecx
callq 0x3893d
movq %rax, 0x48(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdi
callq 0x390ec
leaq 0x3431a(%rip), %rdi     # 0x1099b0
leaq 0x3374a(%rip), %rsi     # 0x108de7
movq %r12, %rdx
movl $0x1, %ecx
callq 0x3893d
movq %rax, 0x60(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0xdc(%r14), %rdx
leaq 0x33738(%rip), %rdi     # 0x108dff
leaq 0x3373a(%rip), %rsi     # 0x108e08
xorl %ecx, %ecx
callq 0x3893d
movq %rax, 0x98(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
movq 0x8(%r14), %rdx
leaq 0x2ee92(%rip), %rdi     # 0x104584
leaq 0x33738(%rip), %rsi     # 0x108e31
xorl %ecx, %ecx
callq 0x38e78
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0xd4(%r14), %rdx
leaq 0x205cf(%rip), %rdi     # 0xf5cec
leaq 0x33784(%rip), %rsi     # 0x108ea8
xorl %ecx, %ecx
callq 0x3893d
movq %rax, 0x70(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0xd7(%r14), %rdx
leaq 0x204a5(%rip), %rdi     # 0xf5bed
leaq 0x3376f(%rip), %rsi     # 0x108ebe
xorl %ecx, %ecx
callq 0x3893d
movq %rax, 0x80(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0xd8(%r14), %rdx
leaq 0x33762(%rip), %rdi     # 0x108ed8
leaq 0x33761(%rip), %rsi     # 0x108ede
xorl %ecx, %ecx
callq 0x3893d
movq %rax, 0x78(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
movq 0x78(%r14), %rdi
callq 0x390cc
leaq 0x2edb0(%rip), %rdi     # 0x104553
leaq 0x3374a(%rip), %rsi     # 0x108ef4
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x3893d
movq %rax, 0xa0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0x3375c(%rip), %rdi     # 0x108f29
leaq 0x3375e(%rip), %rsi     # 0x108f32
movq %rbp, %rdx
xorl %ecx, %ecx
callq 0x3893d
movq %rax, 0xa8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdi
callq 0x390ec
movq 0xa8(%r14), %rdi
callq 0x390dc
leaq 0x33735(%rip), %rdi     # 0x108f4b
leaq 0x33739(%rip), %rsi     # 0x108f56
movl $0x40, %ecx
movl $0x3, %r8d
movl $0x1000000, %r9d        # imm = 0x1000000
movq (%rsp), %rdx
callq 0x38dbe
movq %rax, 0xb0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
movq 0xa0(%r14), %rsi
movq 0xb0(%r14), %rdi
callq 0x390ec
leaq 0x33715(%rip), %rdi     # 0x108f78
leaq 0x3371c(%rip), %rsi     # 0x108f86
movsd 0x1661e(%rip), %xmm0    # 0xebe90
movq 0x8(%rsp), %rdx
callq 0x38a4e
movq %rax, 0xb8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
movq 0xa0(%r14), %rsi
movq 0xb8(%r14), %rdi
callq 0x390ec
leaq 0x336ff(%rip), %rdi     # 0x108fa7
leaq 0x33701(%rip), %rsi     # 0x108fb0
movl $0x1, %ecx
movl $0x1000000, %r9d        # imm = 0x1000000
movq 0x10(%rsp), %rdx
xorl %r8d, %r8d
callq 0x38dbe
movq %rax, 0xc0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
movq 0xa0(%r14), %rsi
movq 0xc0(%r14), %rdi
callq 0x390ec
movq 0xc8(%r14), %rdx
leaq 0x1d610(%rip), %rdi     # 0xf2f0a
leaq 0x336ec(%rip), %rsi     # 0x108fed
callq 0x38ee7
movq %rax, 0x20(%r14)
movq 0x10(%r14), %rdx
leaq 0x2ecdb(%rip), %rdi     # 0x1045f0
leaq 0x336e8(%rip), %rsi     # 0x109004
xorl %ecx, %ecx
callq 0x38e78
movq %rax, 0x88(%r14)
leaq 0x2f037(%rip), %rsi     # 0x104968
movq %rbx, %rdi
callq 0x3641c
testq %rax, %rax
jne 0xd596f
movq (%r14), %rdx
leaq 0x2f020(%rip), %rdi     # 0x104968
leaq 0x336de(%rip), %rsi     # 0x10902d
xorl %ecx, %ecx
callq 0x38e78
movq %rax, 0x28(%r14)
cmpb $0x1, 0xdb(%r14)
jne 0xd596f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
cmpb $0x1, 0xda(%r14)
jne 0xd5988
leaq 0x20(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x363c8
movq 0x88(%r14), %rsi
movq %rbx, %rdi
callq 0x363c8
movq 0x70(%r14), %rsi
movq 0x88(%r14), %rdi
callq 0x3929e
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdi
callq 0x3929e
movq 0x70(%r14), %rdi
movq 0x80(%r14), %rsi
callq 0x3929e
jmp 0xd5a08
testq %r15, %r15
jne 0xd555a
jmp 0xd5575
leaq 0xd9(%r14), %rdx
leaq 0x27e8a(%rip), %rdi     # 0xfd872
leaq 0x33665(%rip), %rsi     # 0x109054
xorl %ecx, %ecx
callq 0x3893d
movq %rax, 0x90(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
leaq 0x3367e(%rip), %rsi     # 0x10908d
movq %rbx, %rdi
callq 0x3641c
testq %rax, %rax
jne 0xd5a47
leaq 0xd3(%r14), %rdx
leaq 0x33663(%rip), %rdi     # 0x10908d
leaq 0x33665(%rip), %rsi     # 0x109096
xorl %ecx, %ecx
callq 0x3893d
movq %rax, 0x50(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x363c8
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0xd5a66
movq %r14, %rax
addq $0xa0, %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xd5a66
callq 0x3929e
leaq 0x3b6(%rip), %rsi       # 0xd5e23
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3646e
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq