// File: /workspace/github_c_makefile_star2_O1/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 0xb0280
movq %rdi, %rbp
leaq 0x2a8d25(%rip), %rdi    # 0x358ad2
leaq 0x2a8d7f(%rip), %rsi    # 0x358b33
callq 0x10cc4e
movq %rax, %rbx
leaq 0x2a8d95(%rip), %rsi    # 0x358b58
movq %rax, %rdi
callq 0x10ceab
leaq 0x38(%rbp), %rdx
leaq 0x29f546(%rip), %rdi    # 0x34f31c
leaq 0x2a8da2(%rip), %rsi    # 0x358b7f
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x80(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x39(%rbp), %rdx
leaq 0x2edd93(%rip), %rdi    # 0x39db95
leaq 0x2a8d87(%rip), %rsi    # 0x358b90
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x3a(%rbp), %rdx
leaq 0x2d31e0(%rip), %rdi    # 0x38300b
leaq 0x2a8d6e(%rip), %rsi    # 0x358ba0
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x90(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x3b(%rbp), %rdx
leaq 0x2a92bb(%rip), %rdi    # 0x359112
leaq 0x2a8d59(%rip), %rsi    # 0x358bb7
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x58(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x3c(%rbp), %rdx
leaq 0x2a8d61(%rip), %rdi    # 0x358be1
leaq 0x2a8d47(%rip), %rsi    # 0x358bce
xorl %ecx, %ecx
callq 0x10f451
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x41(%rbp), %rdx
leaq 0x2c21d5(%rip), %rdi    # 0x37207c
leaq 0x2a8d3b(%rip), %rsi    # 0x358be9
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x88(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x3d(%rbp), %rdx
leaq 0x2a8d4a(%rip), %rdi    # 0x358c1d
leaq 0x2a8d4e(%rip), %rsi    # 0x358c28
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x78(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x3e(%rbp), %rdx
leaq 0x2a8d58(%rip), %rdi    # 0x358c54
leaq 0x2a8d5b(%rip), %rsi    # 0x358c5e
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x68(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x3f(%rbp), %rdx
leaq 0x2a8dcd(%rip), %rdi    # 0x358cf2
leaq 0x2a8dd4(%rip), %rsi    # 0x358d00
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x40(%rbp), %rdx
leaq 0x2a8ddf(%rip), %rdi    # 0x358d2d
leaq 0x2a8de6(%rip), %rsi    # 0x358d3b
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x42(%rbp), %rdx
leaq 0x2a8e0d(%rip), %rdi    # 0x358d84
leaq 0x2a8e10(%rip), %rsi    # 0x358d8e
xorl %ecx, %ecx
callq 0x10f451
movq %rax, 0x70(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x8(%rbp), %rdx
leaq 0x33a945(%rip), %rdi    # 0x3ea8e5
leaq 0x2a8e13(%rip), %rsi    # 0x358dba
callq 0x10f9b8
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, 0x10(%rsp)
callq 0x10cd10
movq 0x10(%rbp), %rdx
leaq 0x2c3feb(%rip), %rdi    # 0x373fb5
leaq 0x2a8e00(%rip), %rsi    # 0x358dd1
callq 0x10f9f6
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x18(%rbp), %rdx
leaq 0x2e0f67(%rip), %rdi    # 0x390f56
leaq 0x2a8df0(%rip), %rsi    # 0x358de6
callq 0x10f9b8
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x20(%rbp), %rdx
leaq 0x2bb8f6(%rip), %rdi    # 0x36b90c
leaq 0x2a8e28(%rip), %rsi    # 0x358e45
callq 0x10f9b8
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq 0x28(%rbp), %rdx
leaq 0x2a8e8d(%rip), %rdi    # 0x358eca
leaq 0x2a8e89(%rip), %rsi    # 0x358ecd
callq 0x10f9b8
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
movq (%rbp), %rdx
leaq 0x2d6e60(%rip), %rdi    # 0x386ec4
leaq 0x2a8e8d(%rip), %rsi    # 0x358ef8
leaq 0x318549(%rip), %rcx    # 0x3c85bb
callq 0x10f987
movq %rbx, %rdi
movq %rax, %rsi
callq 0x10cd10
leaq 0x48(%rbp), %rdx
leaq 0x31e116(%rip), %rdi    # 0x3ce1a3
leaq 0x2a8e84(%rip), %rsi    # 0x358f18
movl $0x1, %ecx
callq 0x10f880
movq %rax, 0x50(%rsp)
movq %rbx, %rdi
movq %rbx, 0x48(%rsp)
movq %rax, %rsi
callq 0x10cd10
addq $0x30, %rbp
leaq 0x31ab17(%rip), %rdi    # 0x3cabd5
leaq 0x2a8e7f(%rip), %rsi    # 0x358f44
xorps %xmm0, %xmm0
movq %rbp, %rdx
callq 0x10f627
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, %rbx
movq %rax, 0x40(%rsp)
callq 0x10cd10
movq %r14, %rdi
movq %r12, %r14
movq %r12, %rsi
callq 0x10faa6
movq 0x58(%rsp), %r12
movq %r12, %rdi
movq %r15, 0x38(%rsp)
movq %r15, %rsi
callq 0x10faa6
movq 0x60(%rsp), %r13
movq %r13, %rdi
movq 0x80(%rsp), %rbp
movq %rbp, %rsi
callq 0x10fd9f
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x10fd9f
movq %r12, %rdi
movq %r15, %rsi
callq 0x10fd9f
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x10fd9f
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0x10fd9f
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10fc6f
movq %r12, %rdi
movq 0x10(%rsp), %r12
movq %r12, %rsi
movq %r14, %rdx
callq 0x10fc6f
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x10fc6f
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x10fc6f
movq %r13, %rdi
movq 0x28(%rsp), %r13
movq %r13, %rsi
movq 0x18(%rsp), %r15
movq %r15, %rdx
callq 0x10fc6f
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x10fc6f
movq 0x68(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x10fc6f
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x10fc6f
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x10fc6f
movq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x10fbff
movq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x10fbff
movq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x10fbff
movq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10fbff
movq 0x50(%rsp), %rdi
callq 0x10fbdf
movq %r12, %rdi
callq 0x10fbdf
movq 0x88(%rsp), %rdi
callq 0x10fbdf
movq %r14, %rdi
callq 0x10fbdf
movq 0x70(%rsp), %rdi
callq 0x10fbef
movq 0x8(%rsp), %rdi
callq 0x10fbef
movq 0x48(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1c23f