// File: /workspace/github_c_makefile_star2_O2/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 0x35f75(%rip), %rsi     # 0xf19ed
pushq $0x52
popq %rdx
movl $0xf8, %edi
callq 0xccb0
movq %rax, %r14
callq 0x13d5c
movq %rax, (%r14)
callq 0x13d5c
movq %rax, 0x8(%r14)
callq 0x13d5c
movq %rax, 0x10(%r14)
callq 0x13d5c
movq %rax, 0x18(%r14)
callq 0x1532c
movq %rax, 0xc8(%r14)
andw $0x0, 0xdd(%r14)
andl $0x0, 0xd0(%r14)
movb $0x0, 0xd4(%r14)
andl $0x0, 0xd6(%r14)
movq $0x40, 0xe0(%r14)
movabsq $0x4000000000000000, %rax # imm = 0x4000000000000000
movq %rax, 0xf0(%r14)
movq $0x1, 0xe8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x30(%r14)
andq $0x0, 0x60(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x70(%r14)
movups %xmm0, 0x80(%r14)
andq $0x0, 0x90(%r14)
movups %xmm0, 0xb0(%r14)
movups %xmm0, 0xa0(%r14)
andq $0x0, 0xc0(%r14)
testq %r15, %r15
setne 0xda(%r14)
testq %r12, %r12
setne 0xdb(%r14)
je 0xbbff0
movq (%r14), %rdi
callq 0x152db
movq %r12, %rdi
callq 0x146aa
movq %rax, (%r14)
testb $0x1, 0xda(%r14)
je 0xbbb9c
movq 0xc8(%r14), %rdi
callq 0x1583a
movq %r15, %rdi
callq 0x15356
movq %rax, 0xc8(%r14)
cmpl $0x1, %ebp
je 0xbbffe
testl %ebp, %ebp
jne 0xbc02c
leaq 0xd0(%r14), %rbp
leaq 0xd6(%r14), %r12
leaq 0xdd(%r14), %r15
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 0x363a3(%rip), %rdi     # 0xf1fa3
leaq 0x363a0(%rip), %rsi     # 0xf1fa7
pushq $0x1
popq %r13
movl %r13d, %ecx
callq 0x108ef
movq %rax, 0x58(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
movq 0x58(%r14), %rdi
callq 0x11062
leaq 0xd1(%r14), %rdx
leaq 0x2f0a1(%rip), %rdi     # 0xeacda
leaq 0x363ca(%rip), %rsi     # 0xf200a
movl %r13d, %ecx
callq 0x108ef
movq %rax, 0x38(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0x2f03b(%rip), %rdi     # 0xeac99
leaq 0x363d1(%rip), %rsi     # 0xf2036
movq %rbp, %rdx
movl %r13d, %ecx
callq 0x108ef
movq %rax, 0x40(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0xd2(%r14), %rdx
leaq 0x2f002(%rip), %rdi     # 0xeac8f
leaq 0x363c7(%rip), %rsi     # 0xf205b
movl %r13d, %ecx
callq 0x108ef
movq %rax, 0x48(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdi
callq 0x110a5
leaq 0x36fa1(%rip), %rdi     # 0xf2c60
leaq 0x363cd(%rip), %rsi     # 0xf2093
movq %r12, %rdx
movl %r13d, %ecx
callq 0x108ef
movq %rax, 0x60(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0xdc(%r14), %rdx
leaq 0x363bd(%rip), %rdi     # 0xf20ab
leaq 0x363bf(%rip), %rsi     # 0xf20b4
xorl %ecx, %ecx
callq 0x108ef
movq %rax, 0x98(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
movq 0x8(%r14), %rdx
leaq 0x31aeb(%rip), %rdi     # 0xed804
leaq 0x363bd(%rip), %rsi     # 0xf20dd
xorl %ecx, %ecx
callq 0x10c6a
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0xd4(%r14), %rdx
leaq 0x23308(%rip), %rdi     # 0xdf04c
leaq 0x36409(%rip), %rsi     # 0xf2154
xorl %ecx, %ecx
callq 0x108ef
movq %rax, 0x70(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0xd7(%r14), %rdx
leaq 0x231de(%rip), %rdi     # 0xdef4d
leaq 0x363f4(%rip), %rsi     # 0xf216a
xorl %ecx, %ecx
callq 0x108ef
movq %rax, 0x80(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0xd8(%r14), %rdx
leaq 0x363e7(%rip), %rdi     # 0xf2184
leaq 0x363e6(%rip), %rsi     # 0xf218a
xorl %ecx, %ecx
callq 0x108ef
movq %rax, 0x78(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
movq 0x78(%r14), %rdi
callq 0x1101f
leaq 0x31a09(%rip), %rdi     # 0xed7d3
leaq 0x363cf(%rip), %rsi     # 0xf21a0
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x108ef
movq %rax, 0xa0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0x363e1(%rip), %rdi     # 0xf21d5
leaq 0x363e3(%rip), %rsi     # 0xf21de
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x108ef
movq %rax, 0xa8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdi
callq 0x110a5
movq 0xa8(%r14), %rdi
callq 0x11062
leaq 0x363b8(%rip), %rdi     # 0xf21f7
leaq 0x363bc(%rip), %rsi     # 0xf2202
pushq $0x40
popq %rcx
pushq $0x3
popq %r8
movl $0x1000000, %r9d        # imm = 0x1000000
movq 0x10(%rsp), %rdx
callq 0x10bf7
movq %rax, 0xb0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
movq 0xa0(%r14), %rsi
movq 0xb0(%r14), %rdi
callq 0x110a5
leaq 0x3639b(%rip), %rdi     # 0xf2224
leaq 0x363a2(%rip), %rsi     # 0xf2232
movsd 0x18fe8(%rip), %xmm0    # 0xd4e80
movq 0x18(%rsp), %rdx
callq 0x10a2f
movq %rax, 0xb8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
movq 0xa0(%r14), %rsi
movq 0xb8(%r14), %rdi
callq 0x110a5
leaq 0x36385(%rip), %rdi     # 0xf2253
leaq 0x36387(%rip), %rsi     # 0xf225c
pushq $0x1
popq %rcx
movl $0x1000000, %r9d        # imm = 0x1000000
movq 0x20(%rsp), %rdx
xorl %r8d, %r8d
callq 0x10bf7
movq %rax, 0xc0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
movq 0xa0(%r14), %rsi
movq 0xc0(%r14), %rdi
callq 0x110a5
movq 0xc8(%r14), %rdx
leaq 0x2034c(%rip), %rdi     # 0xdc26a
leaq 0x36374(%rip), %rsi     # 0xf2299
callq 0x10cd6
movq %rax, 0x20(%r14)
movq 0x10(%r14), %rdx
leaq 0x31937(%rip), %rdi     # 0xed870
leaq 0x36370(%rip), %rsi     # 0xf22b0
xorl %ecx, %ecx
callq 0x10c6a
movq %rax, 0x88(%r14)
leaq 0x31c93(%rip), %rsi     # 0xedbe8
movq %rbx, %rdi
callq 0xdf0e
testq %rax, %rax
jne 0xbbf93
movq (%r14), %rdx
leaq 0x31c7c(%rip), %rdi     # 0xedbe8
leaq 0x36366(%rip), %rsi     # 0xf22d9
xorl %ecx, %ecx
callq 0x10c6a
movq %rax, 0x28(%r14)
cmpb $0x1, 0xdb(%r14)
jne 0xbbf93
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
cmpb $0x1, 0xda(%r14)
jne 0xbbfac
leaq 0x20(%r14), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0xde89
movq 0x88(%r14), %rsi
movq %rbx, %rdi
callq 0xde89
movq 0x70(%r14), %rsi
movq 0x88(%r14), %rdi
callq 0x112e5
movq 0x80(%r14), %rsi
movq 0x88(%r14), %rdi
callq 0x112e5
movq 0x70(%r14), %rdi
movq 0x80(%r14), %rsi
callq 0x112e5
jmp 0xbc02c
testq %r15, %r15
jne 0xbbb81
jmp 0xbbb9c
leaq 0xd9(%r14), %rdx
leaq 0x2ab66(%rip), %rdi     # 0xe6b72
leaq 0x362ed(%rip), %rsi     # 0xf2300
xorl %ecx, %ecx
callq 0x108ef
movq %rax, 0x90(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
leaq 0x36306(%rip), %rsi     # 0xf2339
movq %rbx, %rdi
callq 0xdf0e
testq %rax, %rax
jne 0xbc06b
leaq 0xd3(%r14), %rdx
leaq 0x362eb(%rip), %rdi     # 0xf2339
leaq 0x362ed(%rip), %rsi     # 0xf2342
xorl %ecx, %ecx
callq 0x108ef
movq %rax, 0x50(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xde89
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0xbc08a
movq %r14, %rax
addq $0xa0, %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xbc08a
callq 0x112e5
leaq 0xc45(%rip), %rsi       # 0xbccd6
movq %rbx, %rdi
movq %r14, %rdx
callq 0xe02c
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq