// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0xa8(%rsp)
cmpq $0x0, 0xa8(%rsp)
jne 0x40c02
movq 0x5fb3cf(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4d5438(%rip), %rsi    # 0x516013
leaq 0x539f7d(%rip), %rdx    # 0x57ab5f
leaq 0x4dfef5(%rip), %rcx    # 0x520ade
leaq 0x4dfed0(%rip), %r8     # 0x520ac0
movl $0x90, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x40c04
leaq 0x4dfef7(%rip), %rdi    # 0x520b02
leaq 0x4dff51(%rip), %rsi    # 0x520b63
callq 0xf1420
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
leaq 0x4dff5a(%rip), %rsi    # 0x520b88
callq 0xf1a10
movq 0xa8(%rsp), %rdx
addq $0x38, %rdx
leaq 0x4d66ee(%rip), %rdi    # 0x517334
leaq 0x4dff62(%rip), %rsi    # 0x520baf
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x88(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x39, %rdx
leaq 0x5263ef(%rip), %rdi    # 0x567073
leaq 0x4dff35(%rip), %rsi    # 0x520bc0
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x80(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x3a, %rdx
leaq 0x50b393(%rip), %rdi    # 0x54c055
leaq 0x4dff07(%rip), %rsi    # 0x520bd0
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x38(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x3b, %rdx
leaq 0x4e0448(%rip), %rdi    # 0x521142
leaq 0x4dfee6(%rip), %rsi    # 0x520be7
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x78(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x78(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x3c, %rdx
leaq 0x4dfedf(%rip), %rdi    # 0x520c11
leaq 0x4dfec5(%rip), %rsi    # 0x520bfe
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x70(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x41, %rdx
leaq 0x4f9526(%rip), %rdi    # 0x53a290
leaq 0x4dfea8(%rip), %rsi    # 0x520c19
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x3d, %rdx
leaq 0x4dfeab(%rip), %rdi    # 0x520c4d
leaq 0x4dfeaf(%rip), %rsi    # 0x520c58
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x68(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x3e, %rdx
leaq 0x4dfeaa(%rip), %rdi    # 0x520c84
leaq 0x4dfead(%rip), %rsi    # 0x520c8e
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x48(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x3f, %rdx
leaq 0x4dff10(%rip), %rdi    # 0x520d22
leaq 0x4dff17(%rip), %rsi    # 0x520d30
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x40(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x40, %rdx
leaq 0x4dff13(%rip), %rdi    # 0x520d5d
leaq 0x4dff1a(%rip), %rsi    # 0x520d6b
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x10(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x42, %rdx
leaq 0x4dff32(%rip), %rdi    # 0x520db4
leaq 0x4dff35(%rip), %rsi    # 0x520dbe
xorl %ecx, %ecx
callq 0xf5f20
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rax
movq 0x8(%rax), %rdx
leaq 0x575902(%rip), %rdi    # 0x5b67bc
leaq 0x4dff29(%rip), %rsi    # 0x520dea
callq 0xf6a50
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rax
movq 0x10(%rax), %rdx
leaq 0x4fb4ab(%rip), %rdi    # 0x53c3a1
leaq 0x4dff04(%rip), %rsi    # 0x520e01
callq 0xf6b00
movq %rax, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x51942a(%rip), %rdi    # 0x55a35c
leaq 0x4dfedd(%rip), %rsi    # 0x520e16
callq 0xf6a50
movq %rax, 0x60(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rax
movq 0x20(%rax), %rdx
leaq 0x4f2af6(%rip), %rdi    # 0x533a5e
leaq 0x4dff06(%rip), %rsi    # 0x520e75
callq 0xf6a50
movq %rax, 0x58(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rax
movq 0x28(%rax), %rdx
leaq 0x4dff5c(%rip), %rdi    # 0x520efa
leaq 0x4dff58(%rip), %rsi    # 0x520efd
callq 0xf6a50
movq %rax, 0x30(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rax
movq (%rax), %rdx
leaq 0x50f121(%rip), %rdi    # 0x5500f4
leaq 0x4dff4e(%rip), %rsi    # 0x520f28
leaq 0x5510ea(%rip), %rcx    # 0x5920cb
callq 0xf69f0
movq %rax, 0x50(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x48, %rdx
leaq 0x556e43(%rip), %rdi    # 0x597e53
leaq 0x4dff31(%rip), %rsi    # 0x520f48
movl $0x1, %ecx
callq 0xf67d0
movq %rax, 0x20(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xf1600
movq 0xa8(%rsp), %rdx
addq $0x30, %rdx
leaq 0x5282e9(%rip), %rdi    # 0x569334
leaq 0x4dff22(%rip), %rsi    # 0x520f74
xorps %xmm0, %xmm0
callq 0xf62c0
movq %rax, 0x28(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xf1600
movq 0x98(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0xf6cf0
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xf6cf0
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf7320
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xf7320
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xf7320
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf7320
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xf7320
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0xf7150
movq 0x78(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0xf7150
movq 0x98(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdx
callq 0xf7150
movq 0x70(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0xf7150
movq 0x80(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xf7150
movq 0x88(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xf7150
movq 0x48(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xf7150
movq 0x40(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
callq 0xf7150
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0xf7150
movq 0x38(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0xf7090
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf7090
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xf7090
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0xf7090
movq 0x20(%rsp), %rdi
callq 0xf6ff0
movq 0x48(%rsp), %rdi
callq 0xf6ff0
movq 0x8(%rsp), %rdi
callq 0xf6ff0
movq 0x68(%rsp), %rdi
callq 0xf6ff0
movq 0x18(%rsp), %rdi
callq 0xf7040
movq 0x10(%rsp), %rdi
callq 0xf7040
movq 0xa0(%rsp), %rax
addq $0xb8, %rsp
retq
nop