// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x142e56
cmpl $0x2, 0x1c(%rsp)
jne 0x142e8e
movq 0x7117b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x1b1ff(%rip), %rsi     # 0x15e066
leaq 0x48e31(%rip), %rdx     # 0x18bc9f
leaq 0x48e5d(%rip), %rcx     # 0x18bcd2
leaq 0x4886d(%rip), %r8      # 0x18b6e9
movl $0xb8, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x142e90
callq 0x144600
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
setne %cl
movq (%rsp), %rax
andb $0x1, %cl
movb %cl, 0xda(%rax)
cmpq $0x0, 0x10(%rsp)
setne %cl
movq (%rsp), %rax
andb $0x1, %cl
movb %cl, 0xdb(%rax)
movq (%rsp), %rax
testb $0x1, 0xdb(%rax)
je 0x142ef2
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1afc0
movq 0x10(%rsp), %rdi
callq 0x19dc0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
testb $0x1, 0xda(%rax)
je 0x142f27
movq (%rsp), %rax
movq 0xc8(%rax), %rdi
callq 0x1b780
movq 0x8(%rsp), %rdi
callq 0x1b060
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xc8(%rax)
cmpl $0x0, 0x1c(%rsp)
jne 0x143501
movq (%rsp), %rdx
addq $0xd5, %rdx
leaq 0x48db1(%rip), %rdi     # 0x18bcf5
leaq 0x48dae(%rip), %rsi     # 0x18bcf9
movl $0x1, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x58(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x14540
movq (%rsp), %rdx
addq $0xd1, %rdx
leaq 0x41749(%rip), %rdi     # 0x1846da
leaq 0x48dc4(%rip), %rsi     # 0x18bd5c
movl $0x1, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x38(%rax), %rsi
callq 0xeb00
movq (%rsp), %rdx
addq $0xd0, %rdx
leaq 0x416c8(%rip), %rdi     # 0x184699
leaq 0x48db0(%rip), %rsi     # 0x18bd88
movl $0x1, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x40(%rax), %rsi
callq 0xeb00
movq (%rsp), %rdx
addq $0xd2, %rdx
leaq 0x4167e(%rip), %rdi     # 0x18468f
leaq 0x48d95(%rip), %rsi     # 0x18bdad
movl $0x1, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x48(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x14590
movq (%rsp), %rdx
addq $0xd6, %rdx
leaq 0x4996a(%rip), %rdi     # 0x18c9d0
leaq 0x48d78(%rip), %rsi     # 0x18bde5
movl $0x1, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x60(%rax), %rsi
callq 0xeb00
movq (%rsp), %rdx
addq $0xdc, %rdx
leaq 0x48d57(%rip), %rdi     # 0x18bdfd
leaq 0x48d59(%rip), %rsi     # 0x18be06
xorl %ecx, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x98(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x44220(%rip), %rdi     # 0x187306
leaq 0x48d42(%rip), %rsi     # 0x18be2f
xorl %eax, %eax
movl %eax, %ecx
callq 0x13ef0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x30(%rax), %rsi
callq 0xeb00
movq (%rsp), %rdx
addq $0xd4, %rdx
leaq 0x30dd7(%rip), %rdi     # 0x173efc
leaq 0x48d7a(%rip), %rsi     # 0x18bea6
xorl %ecx, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x70(%rax), %rsi
callq 0xeb00
movq (%rsp), %rdx
addq $0xd7, %rdx
leaq 0x30c9b(%rip), %rdi     # 0x173dfd
leaq 0x48d53(%rip), %rsi     # 0x18bebc
xorl %ecx, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x80(%rax), %rsi
callq 0xeb00
movq (%rsp), %rdx
addq $0xd8, %rdx
leaq 0x48d31(%rip), %rdi     # 0x18bed6
leaq 0x48d30(%rip), %rsi     # 0x18bedc
xorl %ecx, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x78(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
movq 0x78(%rax), %rdi
callq 0x144f0
movq (%rsp), %rdx
addq $0xdd, %rdx
leaq 0x440e6(%rip), %rdi     # 0x1872d5
leaq 0x48cfc(%rip), %rsi     # 0x18bef2
xorl %ecx, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xa0(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0xa0(%rax), %rsi
callq 0xeb00
movq (%rsp), %rdx
addq $0xde, %rdx
leaq 0x48cf5(%rip), %rdi     # 0x18bf27
leaq 0x48cf7(%rip), %rsi     # 0x18bf30
xorl %ecx, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xa8(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0xa8(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
movq 0xa8(%rax), %rdi
movq (%rsp), %rax
movq 0xa0(%rax), %rsi
callq 0x14590
movq (%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x14540
movq (%rsp), %rdx
addq $0xe0, %rdx
leaq 0x48ca9(%rip), %rdi     # 0x18bf49
leaq 0x48cad(%rip), %rsi     # 0x18bf54
movl $0x40, %ecx
movl $0x3, %r8d
movl $0x1000000, %r9d        # imm = 0x1000000
callq 0x13d50
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xb0(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0xb0(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
movq 0xb0(%rax), %rdi
movq (%rsp), %rax
movq 0xa0(%rax), %rsi
callq 0x14590
movq (%rsp), %rdx
addq $0xf0, %rdx
leaq 0x48c69(%rip), %rdi     # 0x18bf76
leaq 0x48c70(%rip), %rsi     # 0x18bf84
movsd 0x2500c(%rip), %xmm0    # 0x168328
callq 0x13660
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xb8(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0xb8(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
movq 0xb8(%rax), %rdi
movq (%rsp), %rax
movq 0xa0(%rax), %rsi
callq 0x14590
movq (%rsp), %rdx
addq $0xe8, %rdx
leaq 0x48c34(%rip), %rdi     # 0x18bfa5
leaq 0x48c36(%rip), %rsi     # 0x18bfae
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r8d
movl $0x1000000, %r9d        # imm = 0x1000000
callq 0x13d50
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0xc0(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0xc0(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
movq 0xc0(%rax), %rdi
movq (%rsp), %rax
movq 0xa0(%rax), %rsi
callq 0x14590
movq (%rsp), %rax
movq 0xc8(%rax), %rdx
leaq 0x2dc4d(%rip), %rdi     # 0x17102a
leaq 0x48c07(%rip), %rsi     # 0x18bfeb
callq 0x14000
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x43f6f(%rip), %rdi     # 0x187372
leaq 0x48bf8(%rip), %rsi     # 0x18c002
xorl %eax, %eax
movl %eax, %ecx
callq 0x13ef0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x20(%rsp), %rdi
leaq 0x442bd(%rip), %rsi     # 0x1876ea
callq 0xebb0
cmpq $0x0, %rax
jne 0x143482
movq (%rsp), %rax
movq (%rax), %rdx
leaq 0x442a4(%rip), %rdi     # 0x1876ea
leaq 0x48bde(%rip), %rsi     # 0x18c02b
xorl %eax, %eax
movl %eax, %ecx
callq 0x13ef0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
testb $0x1, 0xdb(%rax)
je 0x143480
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x28(%rax), %rsi
callq 0xeb00
jmp 0x143482
movq (%rsp), %rax
testb $0x1, 0xda(%rax)
je 0x1434a1
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
callq 0xeb00
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x88(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
movq 0x88(%rax), %rdi
movq (%rsp), %rax
movq 0x70(%rax), %rsi
callq 0x14820
movq (%rsp), %rax
movq 0x88(%rax), %rdi
movq (%rsp), %rax
movq 0x80(%rax), %rsi
callq 0x14820
movq (%rsp), %rax
movq 0x70(%rax), %rdi
movq (%rsp), %rax
movq 0x80(%rax), %rsi
callq 0x14820
cmpl $0x1, 0x1c(%rsp)
jne 0x14354b
movq (%rsp), %rdx
addq $0xd9, %rdx
leaq 0x38818(%rip), %rdi     # 0x17bd32
leaq 0x48b31(%rip), %rsi     # 0x18c052
xorl %ecx, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x90(%rax), %rsi
callq 0xeb00
movq 0x20(%rsp), %rdi
leaq 0x48b34(%rip), %rsi     # 0x18c08b
callq 0xebb0
cmpq $0x0, %rax
jne 0x14359f
movq (%rsp), %rdx
addq $0xd3, %rdx
leaq 0x48b17(%rip), %rdi     # 0x18c08b
leaq 0x48b19(%rip), %rsi     # 0x18c094
xorl %ecx, %ecx
callq 0x13420
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq 0x50(%rax), %rsi
callq 0xeb00
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x1435d0
movq (%rsp), %rax
cmpq $0x0, 0xa0(%rax)
je 0x1435d0
movq (%rsp), %rax
movq 0x50(%rax), %rdi
movq (%rsp), %rax
movq 0xa0(%rax), %rsi
callq 0x14820
movq 0x20(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x1250(%rip), %rsi      # 0x144830
callq 0xed60
movq (%rsp), %rax
addq $0x28, %rsp
retq
nop