// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x108, %rsp            # imm = 0x108
movq %rdi, 0x100(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0xf8(%rsp)
cmpq $0x0, 0xf8(%rsp)
jne 0x68fa2
movq 0x5d302f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4ad098(%rip), %rsi    # 0x516013
leaq 0x4ae302(%rip), %rdx    # 0x517284
leaq 0x4c1677(%rip), %rcx    # 0x52a600
leaq 0x4c165a(%rip), %r8     # 0x52a5ea
movl $0xa8, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x68fa4
leaq 0x4c540a(%rip), %rdi    # 0x52e3b5
leaq 0x4c166a(%rip), %rsi    # 0x52a61c
callq 0xf1420
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rdi
leaq 0x4ae316(%rip), %rsi    # 0x5172e4
callq 0xf1a10
movq 0xf8(%rsp), %rax
movq 0x20(%rax), %rdx
leaq 0x4c1d62(%rip), %rdi    # 0x52ad48
leaq 0x4b1d64(%rip), %rsi    # 0x51ad51
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x88(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rax
movq 0x28(%rax), %rdx
leaq 0x4b5828(%rip), %rdi    # 0x51e84e
leaq 0x4b1d4a(%rip), %rsi    # 0x51ad77
xorl %eax, %eax
movl %eax, %ecx
callq 0xf69f0
movq %rax, 0x90(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rax
movq 0x40(%rax), %rdx
leaq 0x4c15e7(%rip), %rdi    # 0x52a64d
leaq 0x4c15eb(%rip), %rsi    # 0x52a658
callq 0xf6a50
movq %rax, 0x70(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x30, %rdx
leaq 0x51f7a2(%rip), %rdi    # 0x58883e
leaq 0x4c15d1(%rip), %rsi    # 0x52a674
xorl %ecx, %ecx
callq 0xf64b0
movq %rax, 0x68(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rax
movq 0x38(%rax), %rdx
leaq 0x4c15bf(%rip), %rdi    # 0x52a693
leaq 0x4c15bf(%rip), %rsi    # 0x52a69a
callq 0xf6a50
movq %rax, 0x60(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xf1600
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0xf6dd0
movq 0xf8(%rsp), %rdx
leaq 0x553816(%rip), %rdi    # 0x5bc936
leaq 0x4c163c(%rip), %rsi    # 0x52a763
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xe8(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x1, %rdx
leaq 0x4c1616(%rip), %rdi    # 0x52a774
leaq 0x4c1617(%rip), %rsi    # 0x52a77c
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x18(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x18, %rdx
leaq 0x4c1631(%rip), %rdi    # 0x52a7c7
leaq 0x4c1636(%rip), %rsi    # 0x52a7d3
xorl %eax, %eax
movl %eax, %ecx
callq 0xf5fe0
movq %rax, 0x98(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x5, %rdx
leaq 0x4bd9cb(%rip), %rdi    # 0x526ba1
leaq 0x4c1616(%rip), %rsi    # 0x52a7f3
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xa8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x7, %rdx
leaq 0x4ae82a(%rip), %rdi    # 0x517a3e
leaq 0x4c15fd(%rip), %rsi    # 0x52a818
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xc8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xc8(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x8, %rdx
leaq 0x4ae7f1(%rip), %rdi    # 0x517a43
leaq 0x4c15d6(%rip), %rsi    # 0x52a82f
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xc0(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x6, %rdx
leaq 0x4f0662(%rip), %rdi    # 0x5598f2
leaq 0x4c15bc(%rip), %rsi    # 0x52a853
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xd0(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0xa, %rdx
leaq 0x520045(%rip), %rdi    # 0x589313
leaq 0x4c1595(%rip), %rsi    # 0x52a86a
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xb0(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x9, %rdx
leaq 0x522b65(%rip), %rdi    # 0x58be71
leaq 0x4c156b(%rip), %rsi    # 0x52a87e
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xb8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0xb, %rdx
leaq 0x50804d(%rip), %rdi    # 0x571397
leaq 0x4c1556(%rip), %rsi    # 0x52a8a7
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xd8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x3, %rdx
leaq 0x4c1536(%rip), %rdi    # 0x52a8be
leaq 0x4c1536(%rip), %rsi    # 0x52a8c5
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x80(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x4, %rdx
leaq 0x4c152a(%rip), %rdi    # 0x52a8f0
leaq 0x4c152a(%rip), %rsi    # 0x52a8f7
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x78(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xf1600
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xf7320
movq 0xf8(%rsp), %rdx
addq $0xc, %rdx
leaq 0x4ae629(%rip), %rdi    # 0x517a39
leaq 0x4c150b(%rip), %rsi    # 0x52a922
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0xa0(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x10, %rdx
leaq 0x4c14f7(%rip), %rdi    # 0x52a945
leaq 0x4c14fa(%rip), %rsi    # 0x52a94f
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x58(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x11, %rdx
leaq 0x4c14e1(%rip), %rdi    # 0x52a967
leaq 0x4c14e9(%rip), %rsi    # 0x52a976
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x50(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0xd, %rdx
leaq 0x4c14de(%rip), %rdi    # 0x52a99c
leaq 0x4c14e3(%rip), %rsi    # 0x52a9a8
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x48(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0xe, %rdx
leaq 0x4c14ce(%rip), %rdi    # 0x52a9c4
leaq 0x4c14d6(%rip), %rsi    # 0x52a9d3
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x40(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0xf, %rdx
leaq 0x4c14c5(%rip), %rdi    # 0x52a9f3
leaq 0x4c14cf(%rip), %rsi    # 0x52aa04
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x38(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x34, %rdx
leaq 0x50d392(%rip), %rdi    # 0x5768f8
leaq 0x4c14d4(%rip), %rsi    # 0x52aa41
xorl %ecx, %ecx
callq 0xf64b0
movq %rax, 0x30(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x14, %rdx
leaq 0x50e65c(%rip), %rdi    # 0x577bfa
leaq 0x4c14b3(%rip), %rsi    # 0x52aa58
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x28(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0xf8(%rsp), %rdx
addq $0x15, %rdx
leaq 0x4c14b8(%rip), %rdi    # 0x52aa8e
leaq 0x4c14c0(%rip), %rsi    # 0x52aa9d
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x20(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf1600
movq 0x20(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf7090
movq 0xf8(%rsp), %rdx
addq $0x12, %rdx
leaq 0x4c151b(%rip), %rdi    # 0x52ab3b
leaq 0x4c148f(%rip), %rsi    # 0x52aab6
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x10(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1600
movq 0x10(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf7090
movq 0xf8(%rsp), %rdx
addq $0x13, %rdx
leaq 0x4c15df(%rip), %rdi    # 0x52ac49
leaq 0x4c147e(%rip), %rsi    # 0x52aaef
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0xf0(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0x8(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf7090
movq 0xf8(%rsp), %rdi
addq $0x2, %rdi
callq 0xf5f90
movq %rax, 0xe0(%rsp)
movq 0xf0(%rsp), %rdi
movq 0xe0(%rsp), %rsi
callq 0xf1600
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xf7320
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf7320
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf7320
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf7320
movq 0xb0(%rsp), %rdi
movq 0xd0(%rsp), %rsi
callq 0xf7090
movq 0x48(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf7090
movq 0x68(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf7090
movq 0x60(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xf7090
movq 0xf0(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
nopw %cs:(%rax,%rax)