// File: /workspace/github_c_makefile_star2_O2/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 0x30f7a
movq %rdi, %rbp
leaq 0x2bf001(%rip), %rdi    # 0x2efaaa
leaq 0x2bf05b(%rip), %rsi    # 0x2efb0b
callq 0x97df5
movq %rax, %rbx
leaq 0x2bf071(%rip), %rsi    # 0x2efb30
movq %rax, %rdi
callq 0x98288
leaq 0x38(%rbp), %rdx
leaq 0x2b584a(%rip), %rdi    # 0x2e631c
leaq 0x2bf07e(%rip), %rsi    # 0x2efb57
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x80(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x39(%rbp), %rdx
leaq 0x303f69(%rip), %rdi    # 0x334a67
leaq 0x2bf063(%rip), %rsi    # 0x2efb68
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x60(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x3a(%rbp), %rdx
leaq 0x2e9514(%rip), %rdi    # 0x31a03b
leaq 0x2bf04a(%rip), %rsi    # 0x2efb78
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x90(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x3b(%rbp), %rdx
leaq 0x2bf597(%rip), %rdi    # 0x2f00ea
leaq 0x2bf035(%rip), %rsi    # 0x2efb8f
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x58(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x3c(%rbp), %rdx
leaq 0x2bf03d(%rip), %rdi    # 0x2efbb9
leaq 0x2bf023(%rip), %rsi    # 0x2efba6
xorl %ecx, %ecx
callq 0x9a997
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x41(%rbp), %rdx
leaq 0x2d81dd(%rip), %rdi    # 0x308d80
leaq 0x2bf017(%rip), %rsi    # 0x2efbc1
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x88(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x3d(%rbp), %rdx
leaq 0x2bf026(%rip), %rdi    # 0x2efbf5
leaq 0x2bf02a(%rip), %rsi    # 0x2efc00
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x78(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x3e(%rbp), %rdx
leaq 0x2bf034(%rip), %rdi    # 0x2efc2c
leaq 0x2bf037(%rip), %rsi    # 0x2efc36
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x68(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x3f(%rbp), %rdx
leaq 0x2bf0a9(%rip), %rdi    # 0x2efcca
leaq 0x2bf0b0(%rip), %rsi    # 0x2efcd8
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x30(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x40(%rbp), %rdx
leaq 0x2bf0bb(%rip), %rdi    # 0x2efd05
leaq 0x2bf0c2(%rip), %rsi    # 0x2efd13
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x42(%rbp), %rdx
leaq 0x2bf0e9(%rip), %rdi    # 0x2efd5c
leaq 0x2bf0ec(%rip), %rsi    # 0x2efd66
xorl %ecx, %ecx
callq 0x9a997
movq %rax, 0x70(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x8(%rbp), %rdx
leaq 0x350909(%rip), %rdi    # 0x3815a5
leaq 0x2bf0ef(%rip), %rsi    # 0x2efd92
callq 0x9ad43
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, 0x10(%rsp)
callq 0x97f31
movq 0x10(%rbp), %rdx
leaq 0x2d9fff(%rip), %rdi    # 0x30acc5
leaq 0x2bf0dc(%rip), %rsi    # 0x2efda9
callq 0x9ad7e
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x18(%rbp), %rdx
leaq 0x2f7287(%rip), %rdi    # 0x327f72
leaq 0x2bf0cc(%rip), %rsi    # 0x2efdbe
callq 0x9ad43
movq %rax, 0x28(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x20(%rbp), %rdx
leaq 0x2d1a3e(%rip), %rdi    # 0x302750
leaq 0x2bf104(%rip), %rsi    # 0x2efe1d
callq 0x9ad43
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq 0x28(%rbp), %rdx
leaq 0x2bf169(%rip), %rdi    # 0x2efea2
leaq 0x2bf165(%rip), %rsi    # 0x2efea5
callq 0x9ad43
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
movq (%rbp), %rdx
leaq 0x2ed1fc(%rip), %rdi    # 0x31df5c
leaq 0x2bf169(%rip), %rsi    # 0x2efed0
leaq 0x32e61d(%rip), %rcx    # 0x35f38b
callq 0x9ad12
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97f31
leaq 0x48(%rbp), %rdx
leaq 0x334102(%rip), %rdi    # 0x364e8b
leaq 0x2bf160(%rip), %rsi    # 0x2efef0
pushq $0x1
popq %rcx
callq 0x9ac95
movq %rax, 0x50(%rsp)
movq %rbx, %rdi
movq %rbx, 0x48(%rsp)
movq %rax, %rsi
callq 0x97f31
addq $0x30, %rbp
leaq 0x330b01(%rip), %rdi    # 0x3618b9
leaq 0x2bf15d(%rip), %rsi    # 0x2eff1c
xorps %xmm0, %xmm0
movq %rbp, %rdx
callq 0x9ab56
movq %rbx, %rdi
movq %rax, %rsi
movq %rax, %rbx
movq %rax, 0x40(%rsp)
callq 0x97f31
movq %r14, %rdi
movq %r12, %r14
movq %r12, %rsi
callq 0x9ae7a
movq 0x58(%rsp), %r12
movq %r12, %rdi
movq %r15, 0x38(%rsp)
movq %r15, %rsi
callq 0x9ae7a
movq 0x60(%rsp), %r13
movq %r13, %rdi
movq 0x80(%rsp), %rbp
movq %rbp, %rsi
callq 0x9b38d
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x9b38d
movq %r12, %rdi
movq %r15, %rsi
callq 0x9b38d
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x9b38d
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0x9b38d
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x9b1ed
movq %r12, %rdi
movq 0x10(%rsp), %r12
movq %r12, %rsi
movq %r14, %rdx
callq 0x9b1ed
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x9b1ed
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x9b1ed
movq %r13, %rdi
movq 0x28(%rsp), %r13
movq %r13, %rsi
movq 0x18(%rsp), %r15
movq %r15, %rdx
callq 0x9b1ed
movq %rbp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x9b1ed
movq 0x68(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x9b1ed
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x9b1ed
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x9b1ed
movq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
callq 0x9b14d
movq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x9b14d
movq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x9b14d
movq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9b14d
movq 0x50(%rsp), %rdi
callq 0x9b0c7
movq %r12, %rdi
callq 0x9b0c7
movq 0x88(%rsp), %rdi
callq 0x9b0c7
movq %r14, %rdi
callq 0x9b0c7
movq 0x70(%rsp), %rdi
callq 0x9b10a
movq 0x8(%rsp), %rdi
callq 0x9b10a
movq 0x48(%rsp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x406fe7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2b4088(%rip), %rsi    # 0x2e5013
leaq 0x3176c1(%rip), %rdx    # 0x348653
leaq 0x2beaed(%rip), %rcx    # 0x2efa86
leaq 0x2beac8(%rip), %r8     # 0x2efa68
movl $0x90, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390