// File: /workspace/github_c_makefile_star2_O1/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 0xc8241
movq %rdi, %r15
leaq 0x29e45e(%rip), %rdi    # 0x36618a
leaq 0x29a823(%rip), %rsi    # 0x362556
callq 0x10cc4e
movq %rax, %rbx
leaq 0x28758a(%rip), %rsi    # 0x34f2cc
movq %rax, %rdi
callq 0x10ceab
movq 0x20(%r15), %rdx
leaq 0x29af2d(%rip), %rdi    # 0x362c82
leaq 0x28afaa(%rip), %rsi    # 0x352d06
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %rbp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x28(%r15), %rdx
leaq 0x28ea62(%rip), %rdi    # 0x3567de
leaq 0x28afa9(%rip), %rsi    # 0x352d2c
xorl %ecx, %ecx
callq 0x10f987
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x40(%r15), %rdx
leaq 0x29a7e4(%rip), %rdi    # 0x362587
leaq 0x29a7e8(%rip), %rsi    # 0x362592
callq 0x10f9b8
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x30(%r15), %rdx
leaq 0x2f7234(%rip), %rdi    # 0x3beffc
leaq 0x29a7df(%rip), %rsi    # 0x3625ae
xorl %ecx, %ecx
callq 0x10f719
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x38(%r15), %rdx
leaq 0x29a7dc(%rip), %rdi    # 0x3625cd
leaq 0x29a7dc(%rip), %rsi    # 0x3625d4
callq 0x10f9b8
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x10faf4
leaq 0x3286ac(%rip), %rdi    # 0x3f04ce
leaq 0x29a874(%rip), %rsi    # 0x36269d
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x1(%r15), %rdx
leaq 0x29a865(%rip), %rdi    # 0x3626ae
leaq 0x29a866(%rip), %rsi    # 0x3626b6
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x18(%r15), %rdx
leaq 0x29a894(%rip), %rdi    # 0x362701
leaq 0x29a899(%rip), %rsi    # 0x36270d
xorl %ecx, %ecx
callq 0x10f4c7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x5(%r15), %rdx
leaq 0x296c80(%rip), %rdi    # 0x35eb11
leaq 0x29a895(%rip), %rsi    # 0x36272d
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x7(%r15), %rdx
leaq 0x287b71(%rip), %rdi    # 0x34fa26
leaq 0x29a896(%rip), %rsi    # 0x362752
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x8(%r15), %rdx
leaq 0x287b52(%rip), %rdi    # 0x34fa2b
leaq 0x29a889(%rip), %rsi    # 0x362769
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x6(%r15), %rdx
leaq 0x2c8655(%rip), %rdi    # 0x390552
leaq 0x29a889(%rip), %rsi    # 0x36278d
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0xa(%r15), %rdx
leaq 0x2f7bb8(%rip), %rdi    # 0x3bfade
leaq 0x29a877(%rip), %rsi    # 0x3627a4
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x9(%r15), %rdx
leaq 0x2fa5c2(%rip), %rdi    # 0x3c2511
leaq 0x29a862(%rip), %rsi    # 0x3627b8
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0xb(%r15), %rdx
leaq 0x2dfe30(%rip), %rdi    # 0x3a7da3
leaq 0x29a867(%rip), %rsi    # 0x3627e1
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x3(%r15), %rdx
leaq 0x29a861(%rip), %rdi    # 0x3627f8
leaq 0x29a861(%rip), %rsi    # 0x3627ff
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x4(%r15), %rdx
leaq 0x29a86c(%rip), %rdi    # 0x36282a
leaq 0x29a86c(%rip), %rsi    # 0x362831
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r14, %rdi
movq %r12, %rsi
callq 0x10fd9f
leaq 0xc(%r15), %rdx
leaq 0x287a31(%rip), %rdi    # 0x34fa21
leaq 0x29a865(%rip), %rsi    # 0x36285c
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x10(%r15), %rdx
leaq 0x29a86b(%rip), %rdi    # 0x36287f
leaq 0x29a86e(%rip), %rsi    # 0x362889
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x11(%r15), %rdx
leaq 0x29a869(%rip), %rdi    # 0x3628a1
leaq 0x29a871(%rip), %rsi    # 0x3628b0
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0xd(%r15), %rdx
leaq 0x29a87a(%rip), %rdi    # 0x3628d6
leaq 0x29a87f(%rip), %rsi    # 0x3628e2
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0xe(%r15), %rdx
leaq 0x29a879(%rip), %rdi    # 0x3628fe
leaq 0x29a881(%rip), %rsi    # 0x36290d
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0xf(%r15), %rdx
leaq 0x29a881(%rip), %rdi    # 0x36292d
leaq 0x29a88b(%rip), %rsi    # 0x36293e
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x34(%r15), %rdx
leaq 0x2e55fd(%rip), %rdi    # 0x3ad6d2
leaq 0x29a89f(%rip), %rsi    # 0x36297b
xorl %ecx, %ecx
callq 0x10f719
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x14(%r15), %rdx
leaq 0x2e68db(%rip), %rdi    # 0x3ae9d4
leaq 0x29a892(%rip), %rsi    # 0x362992
xorl %ecx, %ecx
callq 0x10f451
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x15(%r15), %rdx
leaq 0x29a8ab(%rip), %rdi    # 0x3629c8
leaq 0x29a8b3(%rip), %rsi    # 0x3629d7
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r14, %rdi
movq %rbp, %r12
movq %rbp, %rsi
callq 0x10fbff
leaq 0x12(%r15), %rdx
leaq 0x29a923(%rip), %rdi    # 0x362a75
leaq 0x29a897(%rip), %rsi    # 0x3629f0
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %r14, %rdi
movq %rbp, %rsi
callq 0x10fbff
leaq 0x13(%r15), %rdx
leaq 0x29a9ff(%rip), %rdi    # 0x362b83
leaq 0x29a89e(%rip), %rsi    # 0x362a29
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %rbp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq %rbp, %rdi
movq %r12, %rsi
callq 0x10fbff
addq $0x2, %r15
movq %r15, %rdi
callq 0x10f473
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x10fd9f
movq %rbp, %rdi
movq %r14, %rsi
callq 0x10fd9f
movq %r15, %rdi
movq 0x8(%rsp), %r14
movq %r14, %rsi
callq 0x10fd9f
movq %r13, %rdi
movq %r14, %rsi
callq 0x10fd9f
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10fbff
movq %r15, %rdi
movq %r12, %rsi
callq 0x10fbff
movq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x10fbff
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x10fbff
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1fa52