// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/tools/gt_sfxmap.c
// Function: gt_sfxmap_option_parser_new
static GtOptionParser* gt_sfxmap_option_parser_new(void *tool_arguments)
{
  Sfxmapoptions *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *optionstream, *optionverbose, *optionbck, *optionsuf,
         *optiondes, *optionsds, *optionbwt, *optionlcp, *optiontis, *optionssp,
         *optiondelspranges, *optionpckindex, *optionesaindex,
         *optioncmpsuf, *optioncmplcp, *optionstreamesq,
         *optionsortmaxdepth, *optionalgbounds, *optiondiffcov,
         *optionwholeleafcheck,
         *optionenumlcpitvs, *optionenumlcpitvtree, *optionenumlcpitvtreeBU,
         *optionscanesa, *optionspmitv, *optionownencseq2file,
         *optionbfcheck, *optioncompressedesa,
         *optioncompresslcp;

  gt_assert(arguments != NULL);
  op = gt_option_parser_new("[options]",
                            "Map or Stream <indexname> and check consistency.");
  gt_option_parser_set_mail_address(op,"<kurtz@zbh.uni-hamburg.de>");

  optionesaindex = gt_option_new_string("esa",
                                        "Specify index (enhanced suffix array)",
                                        arguments->esaindexname, NULL);
  gt_option_parser_add_option(op, optionesaindex);

  optionpckindex = gt_option_new_string("pck",
                                        "Specify index (packed index)",
                                        arguments->pckindexname, NULL);
  gt_option_parser_add_option(op, optionpckindex);

  optionstreamesq = gt_option_new_string_array("stream-esq",
                                               "Stream the encoded sequence",
                                               arguments->streamesq);
  gt_option_parser_add_option(op, optionstreamesq);

  optionsortmaxdepth = gt_option_new_uint("sortmaxdepth",
                                          "sort suffixes up to some depth",
                                          &arguments->sortmaxdepth,0);
  gt_option_parser_add_option(op, optionsortmaxdepth);

  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",
                                arguments->algbounds);
  gt_option_parser_add_option(op, optionalgbounds);

  gt_option_is_mandatory_either_3(optionesaindex,optionpckindex,
                                  optionstreamesq);

  optionstream = gt_option_new_bool("stream","stream the index",
                                    &arguments->usestream,false);
  gt_option_parser_add_option(op, optionstream);

  optionbfcheck = gt_option_new_bool("bfcheck",
                                     "perform check by brute force algorithm "
                                     "(this can be slow if lcps are long)",
                                     &arguments->bfcheck,false);
  gt_option_parser_add_option(op, optionbfcheck);

  optiondelspranges = gt_option_new_uword("delspranges",
                                          "delete ranges of special values",
                                           &arguments->delspranges,
                                           0);
  gt_option_parser_add_option(op, optiondelspranges);

  optiontis = gt_option_new_bool("tis","input the transformed input sequence",
                                 &arguments->inputtis,
                                 false);
  gt_option_parser_add_option(op, optiontis);

  optiondes = gt_option_new_bool("des","input the descriptions",
                                 &arguments->inputdes,
                                 false);
  gt_option_parser_add_option(op, optiondes);

  optionsds = gt_option_new_bool("sds","input the description end positions",
                                 &arguments->inputsds,
                                 false);
  gt_option_parser_add_option(op, optionsds);

  optionsuf = gt_option_new_bool("suf","input the suffix array",
                                 &arguments->inputsuf,
                                 false);
  gt_option_parser_add_option(op, optionsuf);

  optionlcp = gt_option_new_bool("lcp","input the lcp-table",
                                 &arguments->inputlcp,
                                 false);
  gt_option_parser_add_option(op, optionlcp);

  optionbwt = gt_option_new_bool("bwt",
                                 "input the Burrows-Wheeler Transformation",
                                 &arguments->inputbwt,
                                 false);
  gt_option_parser_add_option(op, optionbwt);

  optionbck = gt_option_new_bool("bck","input the bucket table",
                                 &arguments->inputbck,
                                 false);
  gt_option_parser_add_option(op, optionbck);

  optioncmpsuf = gt_option_new_bool("cmpsuf","compare pck derived suftab with "
                                    "esa-suftab",
                                    &arguments->cmpsuf,
                                    false);
  gt_option_parser_add_option(op, optioncmpsuf);

  optioncmplcp = gt_option_new_bool("cmplcp","compare pck derived lcptab with "
                                    "esa-lcptab",
                                    &arguments->cmplcp,
                                    false);
  gt_option_parser_add_option(op, optioncmplcp);
  gt_option_exclude(optioncmpsuf,optioncmplcp);

  optionssp = gt_option_new_bool("ssp","input the sequence separator table",
                                 &arguments->inputssp,
                                 false);
  gt_option_parser_add_option(op, optionssp);

  optiondiffcov = gt_option_new_bool("diffcover","check difference covers",
                                     &arguments->diffcovercheck,false);
  gt_option_parser_add_option(op, optiondiffcov);

  optionwholeleafcheck = gt_option_new_bool("wholeleafcheck",
                                            "check if all whole leaves are "
                                            "present",
                                            &arguments->wholeleafcheck,false);
  gt_option_parser_add_option(op, optionwholeleafcheck);

  optionenumlcpitvs = gt_option_new_bool("enumlcpitvs",
                                         "enumerate the lcp-intervals",
                                         &arguments->enumlcpitvs,false);
  gt_option_parser_add_option(op, optionenumlcpitvs);

  optionenumlcpitvtree = gt_option_new_bool("enumlcpitvtree",
                                            "enumerate the lcp-interval tree",
                                            &arguments->enumlcpitvtree,false);
  gt_option_parser_add_option(op, optionenumlcpitvtree);

  optionenumlcpitvtreeBU = gt_option_new_bool("enumlcpitvtreeBU",
                                      "enumerate the lcp-interval tree "
                                      "(using a bottom-up strategy)",
                                       &arguments->enumlcpitvtreeBU,false);
  gt_option_parser_add_option(op, optionenumlcpitvtreeBU);

  optionscanesa = gt_option_new_uint("scanesa",
                                     "scan suftab and lcptab",
                                     &arguments->scanesa,0);
  gt_option_parser_add_option(op, optionscanesa);

  optionspmitv = gt_option_new_bool("spmitv",
                                    "determine distribution of intervals "
                                    "with whole leaves",
                                    &arguments->spmitv,false);
  gt_option_parser_add_option(op, optionspmitv);

  optionownencseq2file = gt_option_new_bool("ownencseq2file",
                                            "write own encseq to file",
                                            &arguments->ownencseq2file,false);
  gt_option_parser_add_option(op, optionownencseq2file);
  gt_option_imply(optionownencseq2file, optionesaindex);

  optioncompressedesa = gt_option_new_bool("compressedesa",
                                           "input the compressed tables of the "
                                           "enhanced suffix array",
                                           &arguments->compressedesa,
                                           false);
  gt_option_parser_add_option(op, optioncompressedesa);
  gt_option_imply(optioncompressedesa, optionesaindex);

  optioncompresslcp = gt_option_new_bool("compresslcp",
                                          "compress the lcp value into byte "
                                          "compressed form",
                                          &arguments->compresslcp,
                                          false);
  gt_option_parser_add_option(op, optioncompresslcp);
  gt_option_imply(optioncompresslcp, optionesaindex);

  optionverbose = gt_option_new_verbose(&arguments->verbose);
  gt_option_parser_add_option(op, optionverbose);

  gt_option_exclude(optionenumlcpitvs,optionenumlcpitvtree);
  gt_option_exclude(optioncompresslcp,optioncompressedesa);
  gt_option_exclude(optionenumlcpitvs,optionenumlcpitvtreeBU);
  gt_option_exclude(optionenumlcpitvtree,optionenumlcpitvtreeBU);
  gt_option_imply(optionlcp,optionsuf);
  gt_option_imply(optionenumlcpitvs,optionesaindex);
  gt_option_imply(optionsortmaxdepth,optionesaindex);
  gt_option_imply(optionalgbounds,optionsortmaxdepth);
  return op;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x4a5a7
movq %rdi, %r15
leaq 0x2b2fae(%rip), %rdi    # 0x2fd040
leaq 0x2af445(%rip), %rsi    # 0x2f94de
callq 0x97df5
movq %rax, %rbx
leaq 0x29c224(%rip), %rsi    # 0x2e62cc
movq %rax, %rdi
callq 0x98288
movq 0x20(%r15), %rdx
leaq 0x2afb42(%rip), %rdi    # 0x2f9bfd
leaq 0x29fc34(%rip), %rsi    # 0x2e9cf6
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %rbp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x28(%r15), %rdx
leaq 0x2a36cc(%rip), %rdi    # 0x2ed7ae
leaq 0x29fc33(%rip), %rsi    # 0x2e9d1c
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x40(%r15), %rdx
leaq 0x2af406(%rip), %rdi    # 0x2f950f
leaq 0x2af40a(%rip), %rsi    # 0x2f951a
callq 0x9ad43
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x30(%r15), %rdx
leaq 0x30bd0e(%rip), %rdi    # 0x355e3c
leaq 0x2af401(%rip), %rsi    # 0x2f9536
xorl %ecx, %ecx
callq 0x9abcd
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x38(%r15), %rdx
leaq 0x2af3fe(%rip), %rdi    # 0x2f9555
leaq 0x2af3fe(%rip), %rsi    # 0x2f955c
callq 0x9ad43
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x9af22
leaq 0x33cf36(%rip), %rdi    # 0x3870be
leaq 0x2af496(%rip), %rsi    # 0x2f9625
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x1(%r15), %rdx
leaq 0x2af487(%rip), %rdi    # 0x2f9636
leaq 0x2af488(%rip), %rsi    # 0x2f963e
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x18(%r15), %rdx
leaq 0x2af4b6(%rip), %rdi    # 0x2f9689
leaq 0x2af4bb(%rip), %rsi    # 0x2f9695
xorl %ecx, %ecx
callq 0x9a9e6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x5(%r15), %rdx
leaq 0x2ab8fe(%rip), %rdi    # 0x2f5af5
leaq 0x2af4b7(%rip), %rsi    # 0x2f96b5
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x7(%r15), %rdx
leaq 0x29c80b(%rip), %rdi    # 0x2e6a26
leaq 0x2af4b8(%rip), %rsi    # 0x2f96da
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x8(%r15), %rdx
leaq 0x29c7ec(%rip), %rdi    # 0x2e6a2b
leaq 0x2af4ab(%rip), %rsi    # 0x2f96f1
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x6(%r15), %rdx
leaq 0x2dd30b(%rip), %rdi    # 0x32756e
leaq 0x2af4ab(%rip), %rsi    # 0x2f9715
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0xa(%r15), %rdx
leaq 0x30c692(%rip), %rdi    # 0x35691e
leaq 0x2af499(%rip), %rsi    # 0x2f972c
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x9(%r15), %rdx
leaq 0x30f04c(%rip), %rdi    # 0x359301
leaq 0x2af484(%rip), %rsi    # 0x2f9740
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0xb(%r15), %rdx
leaq 0x2f4932(%rip), %rdi    # 0x33ec0b
leaq 0x2af489(%rip), %rsi    # 0x2f9769
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x3(%r15), %rdx
leaq 0x2af483(%rip), %rdi    # 0x2f9780
leaq 0x2af483(%rip), %rsi    # 0x2f9787
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x4(%r15), %rdx
leaq 0x2af48e(%rip), %rdi    # 0x2f97b2
leaq 0x2af48e(%rip), %rsi    # 0x2f97b9
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r14, %rdi
movq %r12, %rsi
callq 0x9b38d
leaq 0xc(%r15), %rdx
leaq 0x29c6cb(%rip), %rdi    # 0x2e6a21
leaq 0x2af487(%rip), %rsi    # 0x2f97e4
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x10(%r15), %rdx
leaq 0x2af48d(%rip), %rdi    # 0x2f9807
leaq 0x2af490(%rip), %rsi    # 0x2f9811
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x11(%r15), %rdx
leaq 0x2af48b(%rip), %rdi    # 0x2f9829
leaq 0x2af493(%rip), %rsi    # 0x2f9838
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0xd(%r15), %rdx
leaq 0x2af49c(%rip), %rdi    # 0x2f985e
leaq 0x2af4a1(%rip), %rsi    # 0x2f986a
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0xe(%r15), %rdx
leaq 0x2af49b(%rip), %rdi    # 0x2f9886
leaq 0x2af4a3(%rip), %rsi    # 0x2f9895
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0xf(%r15), %rdx
leaq 0x2af4a3(%rip), %rdi    # 0x2f98b5
leaq 0x2af4ad(%rip), %rsi    # 0x2f98c6
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x34(%r15), %rdx
leaq 0x2fa068(%rip), %rdi    # 0x3444a3
leaq 0x2af4c1(%rip), %rsi    # 0x2f9903
xorl %ecx, %ecx
callq 0x9abcd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x14(%r15), %rdx
leaq 0x2fb353(%rip), %rdi    # 0x3457b2
leaq 0x2af4b4(%rip), %rsi    # 0x2f991a
xorl %ecx, %ecx
callq 0x9a997
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x15(%r15), %rdx
leaq 0x2af4cd(%rip), %rdi    # 0x2f9950
leaq 0x2af4d5(%rip), %rsi    # 0x2f995f
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r14, %rdi
movq %rbp, %r12
movq %rbp, %rsi
callq 0x9b14d
leaq 0x12(%r15), %rdx
leaq 0x2af545(%rip), %rdi    # 0x2f99fd
leaq 0x2af4b9(%rip), %rsi    # 0x2f9978
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %r14, %rdi
movq %rbp, %rsi
callq 0x9b14d
leaq 0x13(%r15), %rdx
leaq 0x2af621(%rip), %rdi    # 0x2f9b0b
leaq 0x2af4c0(%rip), %rsi    # 0x2f99b1
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %rbp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq %rbp, %rdi
movq %r12, %rsi
callq 0x9b14d
addq $0x2, %r15
movq %r15, %rdi
callq 0x9a9b6
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x9b38d
movq %rbp, %rdi
movq %r14, %rsi
callq 0x9b38d
movq %r15, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x9b38d
movq %r13, %rdi
movq %r14, %rsi
callq 0x9b38d
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9b14d
movq %r15, %rdi
movq %r12, %rsi
callq 0x9b14d
movq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x9b14d
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x9b14d
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3ed9ba(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x29aa5b(%rip), %rsi    # 0x2e5013
leaq 0x29bcad(%rip), %rdx    # 0x2e626c
leaq 0x2aeefc(%rip), %rcx    # 0x2f94c2
leaq 0x2aeedf(%rip), %r8     # 0x2f94ac
movl $0xa8, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390