// File: /workspace/github_c_makefile_star2_O3/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 0xc60dd
movq %rdi, %r15
leaq 0x2974f1(%rip), %rdi    # 0x35d0b9
leaq 0x293937(%rip), %rsi    # 0x359506
callq 0x107bfe
movq %rax, %rbx
leaq 0x2806ee(%rip), %rsi    # 0x3462cc
movq %rax, %rdi
callq 0x107e5c
movq 0x20(%r15), %rdx
leaq 0x294034(%rip), %rdi    # 0x359c25
leaq 0x2840fe(%rip), %rsi    # 0x349cf6
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %rbp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x28(%r15), %rdx
leaq 0x287b96(%rip), %rdi    # 0x34d7ae
leaq 0x2840fd(%rip), %rsi    # 0x349d1c
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x40(%r15), %rdx
leaq 0x2938f8(%rip), %rdi    # 0x359537
leaq 0x2938fc(%rip), %rsi    # 0x359542
callq 0x10a7a1
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x30(%r15), %rdx
leaq 0x2efd78(%rip), %rdi    # 0x3b59dc
leaq 0x2938f3(%rip), %rsi    # 0x35955e
xorl %ecx, %ecx
callq 0x10a4fd
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x38(%r15), %rdx
leaq 0x2938f0(%rip), %rdi    # 0x35957d
leaq 0x2938f0(%rip), %rsi    # 0x359584
callq 0x10a7a1
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x10a8d9
leaq 0x321000(%rip), %rdi    # 0x3e6cbe
leaq 0x293988(%rip), %rsi    # 0x35964d
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x1(%r15), %rdx
leaq 0x293979(%rip), %rdi    # 0x35965e
leaq 0x29397a(%rip), %rsi    # 0x359666
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x18(%r15), %rdx
leaq 0x2939a8(%rip), %rdi    # 0x3596b1
leaq 0x2939ad(%rip), %rsi    # 0x3596bd
xorl %ecx, %ecx
callq 0x10a2ab
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x5(%r15), %rdx
leaq 0x28fdb8(%rip), %rdi    # 0x355ae5
leaq 0x2939a9(%rip), %rsi    # 0x3596dd
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x7(%r15), %rdx
leaq 0x280cd5(%rip), %rdi    # 0x346a26
leaq 0x2939aa(%rip), %rsi    # 0x359702
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x8(%r15), %rdx
leaq 0x280cb6(%rip), %rdi    # 0x346a2b
leaq 0x29399d(%rip), %rsi    # 0x359719
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x6(%r15), %rdx
leaq 0x2c13e0(%rip), %rdi    # 0x387179
leaq 0x29399d(%rip), %rsi    # 0x35973d
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0xa(%r15), %rdx
leaq 0x2f06fc(%rip), %rdi    # 0x3b64be
leaq 0x29398b(%rip), %rsi    # 0x359754
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x9(%r15), %rdx
leaq 0x2f30b6(%rip), %rdi    # 0x3b8ea1
leaq 0x293976(%rip), %rsi    # 0x359768
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0xb(%r15), %rdx
leaq 0x2d8a9c(%rip), %rdi    # 0x39e8ab
leaq 0x29397b(%rip), %rsi    # 0x359791
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x3(%r15), %rdx
leaq 0x293975(%rip), %rdi    # 0x3597a8
leaq 0x293975(%rip), %rsi    # 0x3597af
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x4(%r15), %rdx
leaq 0x293980(%rip), %rdi    # 0x3597da
leaq 0x293980(%rip), %rsi    # 0x3597e1
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r14, %rdi
movq %r12, %rsi
callq 0x10ab96
leaq 0xc(%r15), %rdx
leaq 0x280b95(%rip), %rdi    # 0x346a21
leaq 0x293979(%rip), %rsi    # 0x35980c
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x10(%r15), %rdx
leaq 0x29397f(%rip), %rdi    # 0x35982f
leaq 0x293982(%rip), %rsi    # 0x359839
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x11(%r15), %rdx
leaq 0x29397d(%rip), %rdi    # 0x359851
leaq 0x293985(%rip), %rsi    # 0x359860
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0xd(%r15), %rdx
leaq 0x29398e(%rip), %rdi    # 0x359886
leaq 0x293993(%rip), %rsi    # 0x359892
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0xe(%r15), %rdx
leaq 0x29398d(%rip), %rdi    # 0x3598ae
leaq 0x293995(%rip), %rsi    # 0x3598bd
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0xf(%r15), %rdx
leaq 0x293995(%rip), %rdi    # 0x3598dd
leaq 0x29399f(%rip), %rsi    # 0x3598ee
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x34(%r15), %rdx
leaq 0x2de1c2(%rip), %rdi    # 0x3a4133
leaq 0x2939b3(%rip), %rsi    # 0x35992b
xorl %ecx, %ecx
callq 0x10a4fd
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x14(%r15), %rdx
leaq 0x2df49d(%rip), %rdi    # 0x3a5432
leaq 0x2939a6(%rip), %rsi    # 0x359942
xorl %ecx, %ecx
callq 0x10a235
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x15(%r15), %rdx
leaq 0x2939bf(%rip), %rdi    # 0x359978
leaq 0x2939c7(%rip), %rsi    # 0x359987
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r14, %rdi
movq %rbp, %r12
movq %rbp, %rsi
callq 0x10a9e4
leaq 0x12(%r15), %rdx
leaq 0x293a37(%rip), %rdi    # 0x359a25
leaq 0x2939ab(%rip), %rsi    # 0x3599a0
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %r14, %rdi
movq %rbp, %rsi
callq 0x10a9e4
leaq 0x13(%r15), %rdx
leaq 0x293b13(%rip), %rdi    # 0x359b33
leaq 0x2939b2(%rip), %rsi    # 0x3599d9
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %rbp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x10a9e4
addq $0x2, %r15
movq %r15, %rdi
callq 0x10a257
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x10ab96
movq %rbp, %rdi
movq %r14, %rsi
callq 0x10ab96
movq %r15, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x10ab96
movq %r13, %rdi
movq %r14, %rsi
callq 0x10ab96
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10a9e4
movq %r15, %rdi
movq %r12, %rsi
callq 0x10a9e4
movq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x10a9e4
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10a9e4
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1f6c8