// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/tools/gt_linspace_align.c
// Function: gt_linspace_align_option_parser_new
static GtOptionParser* gt_linspace_align_option_parser_new(void *tool_arguments)
{
  GtLinspaceArguments *arguments = tool_arguments;
  GtOptionParser *op;
  GtOption *optionstrings, *optionfiles, *optionglobal, *optionlocal,
           *optiondna, *optionprotein, *optioncostmatrix, *optionlinearcosts,
           *optionaffinecosts, *optionoutputfile, *optionshowscore,
           *optionshowsequences, *optiondiagonal, *optiondiagonalbonds,
           *optionsimilarity, *optiontsfactor, *optionspacetime,
           *optionscoreonly, *optionwildcardsymbol;

  gt_assert(arguments);

  /* init */
  op = gt_option_parser_new("[ss|ff] sequence1 sequence2 [dna|protein] "
                            "[global|local] [a|l] costs/scores "
                            "[additional options]",
                            "Apply function to compute alignment.");
  gt_option_parser_set_mail_address(op,
                          "<annika.seidel@studium.uni-hamburg.de>");

  /* -bool */
  optionglobal = gt_option_new_bool("global", "global alignment",
                                    &arguments->global, false);
  gt_option_parser_add_option(op, optionglobal);

  optionlocal = gt_option_new_bool("local", "local alignment",
                                   &arguments->local, false);
  gt_option_parser_add_option(op, optionlocal);

  optiondiagonal = gt_option_new_bool("d", "diagonalband alignment",
                                      &arguments->diagonal, false);
  gt_option_parser_add_option(op, optiondiagonal);

  optiondna = gt_option_new_bool("dna", "type of sequences: DNA",
                                 &arguments->dna, false);
  gt_option_parser_add_option(op, optiondna);

  optionprotein = gt_option_new_bool("protein", "type of sequences: protein",
                                      &arguments->protein, false);
  gt_option_parser_add_option(op, optionprotein);

  optionwildcardsymbol = gt_option_new_bool("wildcard", "show symbol used to "
                                            "represented wildcards in output",
                                            &arguments->wildcardshow, false);
  gt_option_parser_add_option(op, optionwildcardsymbol);

  /* special case, if given matrix includes cost values in place of scores */
  optioncostmatrix = gt_option_new_bool("costmatrix", "describes type of "
                                        "given substitution matrix",
                                        &arguments->has_costmatrix, false);
  gt_option_parser_add_option(op, optioncostmatrix);

  optionshowscore = gt_option_new_bool("showscore", "show score for alignment, "
                                       "please note it will calculate costs "
                                       "for global alignments and scores for "
                                       "local alignments always, independently "
                                       "of input ",
                                       &arguments->showscore, false);
  gt_option_parser_add_option(op, optionshowscore);

  optionshowsequences = gt_option_new_bool("showsequences", "show sequences u "
                                           "and v in front of alignment",
                                       &arguments->showsequences, false);
  gt_option_parser_add_option(op, optionshowsequences);

  optionscoreonly = gt_option_new_bool("showonlyscore", "show only score for "
                                       "generated alignment to compare with "
                                       "other algorithms",
                                       &arguments->scoreonly, false);
  gt_option_parser_add_option(op, optionscoreonly);

  optionspacetime = gt_option_new_bool("spacetime", "write space peak and time"
                                       " overall on stdout",
                                       &arguments->spacetime, false);
  gt_option_parser_add_option(op, optionspacetime);

  /* -str */
  optionstrings = gt_option_new_string_array("ss", "input, use two strings",
                                             arguments->strings);
  gt_option_parser_add_option(op, optionstrings);

  optionfiles = gt_option_new_filename_array("ff", "input, use two files",
                                             arguments->files);
  gt_option_parser_add_option(op, optionfiles);

  optionlinearcosts = gt_option_new_string_array("l", "lineargapcosts, "
                                                 "use match, mismatch and "
                                                 "gapcost, alternatively "
                                                 "substitution matrix and "
                                                 "gapcost",
                                                 arguments->linearcosts);
  gt_option_parser_add_option(op, optionlinearcosts);

  optionaffinecosts = gt_option_new_string_array("a", "affinegapcosts, "
                                           "use match, mismatch, gap_extension "
                                           "and gap_opening, alternatively "
                                           "substitution matrix, gap_extension "
                                           "and gap_opening",
                                           arguments->affinecosts);
  gt_option_parser_add_option(op, optionaffinecosts);

  optiondiagonalbonds = gt_option_new_string_array("lr", "specified left and "
                                                   "right shift of diagonal",
                                                   arguments->diagonalbonds);
  gt_option_parser_add_option(op, optiondiagonalbonds);

  optionoutputfile = gt_option_new_string("o", "print alignment, "
                                          "use outputfile",
                                          arguments->outputfile, "stdout");
  gt_option_parser_add_option(op, optionoutputfile);

  /* -ulong */
  optiontsfactor = gt_option_new_ulong("t", "timesquarefactor to organize "
                                       "time and space",
                                       &arguments->timesquarefactor,1);
  gt_option_parser_add_option(op, optiontsfactor);

  /* -double */
  optionsimilarity = gt_option_new_probability("similarity", "specified left "
                                               "and right shift of diagonal by "
                                               "similarity of sequences, "
                                               "0 <= similarty <= 1",
                                               &arguments->similarity, 0);
  gt_option_parser_add_option(op, optionsimilarity);

  /* dependencies */
  gt_option_is_mandatory_either(optionstrings, optionfiles);
  gt_option_is_mandatory_either(optiondna, optionprotein);
  gt_option_exclude(optionlocal, optionglobal);
  gt_option_exclude(optionlinearcosts, optionaffinecosts);
  gt_option_exclude(optiondna, optionprotein);
  gt_option_exclude(optionshowsequences, optionscoreonly);
  gt_option_exclude(optionsimilarity, optiondiagonalbonds);
  gt_option_imply_either_2(optionfiles, optionglobal, optionlocal);
  gt_option_imply_either_2(optiondna, optionstrings, optionfiles);
  gt_option_imply_either_2(optionstrings, optionglobal, optionlocal);
  gt_option_imply_either_2(optionprotein, optionstrings, optionfiles);
  gt_option_imply_either_2(optionlocal, optionlinearcosts, optionaffinecosts);
  gt_option_imply_either_2(optionglobal, optionlinearcosts, optionaffinecosts);
  gt_option_imply_either_2(optionshowscore,optionlinearcosts,optionaffinecosts);
  gt_option_imply_either_2(optionshowsequences, optionstrings, optionfiles);
  gt_option_imply_either_2(optionscoreonly,optionlinearcosts,optionaffinecosts);
  gt_option_imply(optiondiagonal, optionglobal);
  gt_option_imply(optiondiagonalbonds, optiondiagonal);
  gt_option_imply(optionsimilarity, optiondiagonal);
  gt_option_imply(optioncostmatrix, optionprotein);

  /* extended options */
  gt_option_is_extended_option(optiontsfactor);
  gt_option_is_extended_option(optionshowscore);
  gt_option_is_extended_option(optionwildcardsymbol);
  gt_option_is_extended_option(optioncostmatrix);

  /* development option(s) */
  gt_option_is_development_option(optionspacetime);
  gt_option_is_development_option(optionscoreonly);/*only useful to test*/

  return op;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
testq %rdi, %rdi
je 0xadf30
movq %rdi, %rbp
leaq 0x2a2045(%rip), %rdi    # 0x34faa2
leaq 0x2a209f(%rip), %rsi    # 0x34fb03
callq 0x107bfe
movq %rax, %rbx
leaq 0x2a20b5(%rip), %rsi    # 0x34fb28
movq %rax, %rdi
callq 0x107e5c
leaq 0x38(%rbp), %rdx
leaq 0x298896(%rip), %rdi    # 0x34631c
leaq 0x2a20c2(%rip), %rsi    # 0x34fb4f
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x80(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x39(%rbp), %rdx
leaq 0x2e6c46(%rip), %rdi    # 0x3946f8
leaq 0x2a20a7(%rip), %rsi    # 0x34fb60
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x3a(%rbp), %rdx
leaq 0x2cc212(%rip), %rdi    # 0x379ced
leaq 0x2a208e(%rip), %rsi    # 0x34fb70
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x90(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x3b(%rbp), %rdx
leaq 0x2a25db(%rip), %rdi    # 0x3500e2
leaq 0x2a2079(%rip), %rsi    # 0x34fb87
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x58(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x3c(%rbp), %rdx
leaq 0x2a2081(%rip), %rdi    # 0x34fbb1
leaq 0x2a2067(%rip), %rsi    # 0x34fb9e
xorl %ecx, %ecx
callq 0x10a235
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x41(%rbp), %rdx
leaq 0x2bb2cd(%rip), %rdi    # 0x368e24
leaq 0x2a205b(%rip), %rsi    # 0x34fbb9
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x88(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x3d(%rbp), %rdx
leaq 0x2a206a(%rip), %rdi    # 0x34fbed
leaq 0x2a206e(%rip), %rsi    # 0x34fbf8
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x78(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x3e(%rbp), %rdx
leaq 0x2a2078(%rip), %rdi    # 0x34fc24
leaq 0x2a207b(%rip), %rsi    # 0x34fc2e
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x68(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x3f(%rbp), %rdx
leaq 0x2a20ed(%rip), %rdi    # 0x34fcc2
leaq 0x2a20f4(%rip), %rsi    # 0x34fcd0
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x40(%rbp), %rdx
leaq 0x2a20ff(%rip), %rdi    # 0x34fcfd
leaq 0x2a2106(%rip), %rsi    # 0x34fd0b
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x42(%rbp), %rdx
leaq 0x2a212d(%rip), %rdi    # 0x34fd54
leaq 0x2a2130(%rip), %rsi    # 0x34fd5e
xorl %ecx, %ecx
callq 0x10a235
movq %rax, 0x70(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x8(%rbp), %rdx
leaq 0x3335a5(%rip), %rdi    # 0x3e11f5
leaq 0x2a2133(%rip), %rsi    # 0x34fd8a
callq 0x10a7a1
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, 0x10(%rsp)
callq 0x107cc0
movq 0x10(%rbp), %rdx
leaq 0x2bd0eb(%rip), %rdi    # 0x36ad65
leaq 0x2a2120(%rip), %rsi    # 0x34fda1
callq 0x10a7df
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x18(%rbp), %rdx
leaq 0x2d9ede(%rip), %rdi    # 0x387b7d
leaq 0x2a2110(%rip), %rsi    # 0x34fdb6
callq 0x10a7a1
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x20(%rbp), %rdx
leaq 0x2b4b33(%rip), %rdi    # 0x3627f9
leaq 0x2a2148(%rip), %rsi    # 0x34fe15
callq 0x10a7a1
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq 0x28(%rbp), %rdx
leaq 0x2a21ad(%rip), %rdi    # 0x34fe9a
leaq 0x2a21a9(%rip), %rsi    # 0x34fe9d
callq 0x10a7a1
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
movq (%rbp), %rdx
leaq 0x2cfe40(%rip), %rdi    # 0x37db54
leaq 0x2a21ad(%rip), %rsi    # 0x34fec8
leaq 0x311219(%rip), %rcx    # 0x3bef3b
callq 0x10a770
movq %rbx, %rdi
movq %rax, %rsi
callq 0x107cc0
leaq 0x48(%rbp), %rdx
leaq 0x316d3e(%rip), %rdi    # 0x3c4a7b
leaq 0x2a21a4(%rip), %rsi    # 0x34fee8
movl $0x1, %ecx
callq 0x10a664
movq %rax, 0x50(%rsp)
movq %rbx, %rdi
movq %rbx, 0x48(%rsp)
movq %rax, %rsi
callq 0x107cc0
addq $0x30, %rbp
leaq 0x31373b(%rip), %rdi    # 0x3c14a9
leaq 0x2a219f(%rip), %rsi    # 0x34ff14
xorps %xmm0, %xmm0
movq %rbp, %rdx
callq 0x10a40b
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, %rbx
movq %rax, 0x40(%rsp)
callq 0x107cc0
movq %r14, %rdi
movq %r12, %r14
movq %r12, %rsi
callq 0x10a88b
movq 0x58(%rsp), %r12
movq %r12, %rdi
movq %r15, 0x38(%rsp)
movq %r15, %rsi
callq 0x10a88b
movq 0x60(%rsp), %r13
movq %r13, %rdi
movq 0x80(%rsp), %rbp
movq %rbp, %rsi
callq 0x10ab96
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x10ab96
movq %r12, %rdi
movq %r15, %rsi
callq 0x10ab96
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10ab96
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0x10ab96
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10aa54
movq %r12, %rdi
movq 0x10(%rsp), %r12
movq %r12, %rsi
movq %r14, %rdx
callq 0x10aa54
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10aa54
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x10aa54
movq %r13, %rdi
movq 0x28(%rsp), %r13
movq %r13, %rsi
movq 0x18(%rsp), %r15
movq %r15, %rdx
callq 0x10aa54
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x10aa54
movq 0x68(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x10aa54
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x10aa54
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x10aa54
movq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x10a9e4
movq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x10a9e4
movq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x10a9e4
movq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10a9e4
movq 0x50(%rsp), %rdi
callq 0x10a9c4
movq %r12, %rdi
callq 0x10a9c4
movq 0x88(%rsp), %rdi
callq 0x10a9c4
movq %r14, %rdi
callq 0x10a9c4
movq 0x70(%rsp), %rdi
callq 0x10a9d4
movq 0x8(%rsp), %rdi
callq 0x10a9d4
movq 0x48(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c143