<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE pise PUBLIC "pise2.dtd" "pise2.dtd" >
<pise>
	<head>
		<title>RAxML-NG</title>
		<version>1.2.1</version>
		<description>RAxML-NG offers improvements in speed, flexibility and user-friendliness over previous RAxML versions.</description>
		<authors>Alexey M. Kozlov, Diego Darriba, Tomas Flouri, Benoit Morel, and Alexandros Stamatakis</authors>
		<reference>Alexey M. Kozlov, Diego Darriba, Tomas Flouri, Benoit Morel, and Alexandros Stamatakis (2019) RAxML-NG: A fast, scalable, and user-friendly tool for maximum likelihood phylogenetic inference. Bioinformatics, btz305 doi:10.1093/bioinformatics/btz305</reference>
		<category>Phylogeny / Alignment</category>
		<doclink>https://github.com/amkozlov/raxml-ng</doclink>
	</head>
	
	<command>raxmlng_xsede</command>
	<parameters>
<!-- output of the -h command -->
<!-- 
RAxML-NG v. 1.0.1-master released on 26.10.2020 by The Exelixis Lab.
Developed by: Alexey M. Kozlov and Alexandros Stamatakis.
Contributors: Diego Darriba, Tomas Flouri, Benoit Morel, Sarah Lutteropp, Ben Bettisworth.
Latest version: https://github.com/amkozlov/raxml-ng
Questions/problems/suggestions? Please visit: https://groups.google.com/forum/#!forum/raxml

System: AMD EPYC 7742 64-Core Processor, 64 cores, 125 GB RAM

Usage: raxml-ng [OPTIONS]

Commands (mutually exclusive):
  -*help                                     display help information
  -*version                                  display version information
  -*evaluate                                 evaluate the likelihood of a tree (with model+brlen optimization)
  -*search                                   ML tree search (default: 10 parsimony + 10 random starting trees)
  -*bootstrap                                bootstrapping (default: use bootstopping to auto-detect #replicates)
  -*all                                      all-in-one (ML search + bootstrapping)
  -*support                                  compute bipartition support for a given reference tree (e.g., best ML tree)
                                             and a set of replicate trees (e.g., from a bootstrap analysis)
  -*bsconverge                               test for bootstrapping convergence using autoMRE criterion
  -*bsmsa                                    generate bootstrap replicate MSAs
  -*terrace                                  check whether a tree lies on a phylogenetic terrace 
  -*check                                    check alignment correctness and remove empty columns/rows
  -*parse                                    parse alignment, compress patterns and create binary MSA file
  -*start                                    generate parsimony/random starting trees and exit
  -*rfdist                                   compute pair-wise Robinson-Foulds (RF) distances between trees
  -*consense [ STRICT | MR | MR<n> | MRE ]   build strict, majority-rule (MR) or extended MR (MRE) consensus tree (default: MR)
                                             eg: -*consense MR75 -*tree bsrep.nw
  -*ancestral                                ancestral state reconstruction at all inner nodes
  -*sitelh                                   print per-site log-likelihood values

Command shortcuts (mutually exclusive):
  -*search1                                  Alias for: -*search -*tree rand{1}
  -*loglh                                    Alias for: -*evaluate -*opt-model off -*opt-branches off -*nofiles -*log result
  -*rf                                       Alias for: -*rfdist -*nofiles -*log result

Input and output options:
  -*tree            rand{N} | pars{N} | FILE starting tree: rand(om), pars(imony) or user-specified (newick file)
                                             N = number of trees (default: rand{10},pars{10})
  -*msa             FILE                     alignment file
  -*msa-format      VALUE                    alignment file format: FASTA, PHYLIP, CATG or AUTO-detect (default)
  -*data-type       VALUE                    data type: DNA, AA, BIN(ary) or AUTO-detect (default)
  -*tree-constraint FILE                     constraint tree
  -*prefix          STRING                   prefix for output files (default: MSA file name)
  -*log             VALUE                    log verbosity: ERROR,WARNING,RESULT,INFO,PROGRESS,DEBUG (default: PROGRESS)
  -*redo                                     overwrite existing result files and ignore checkpoints (default: OFF)
  -*nofiles                                  do not create any output files, print results to the terminal only
  -*precision       VALUE                    number of decimal places to print (default: 6)
  -*outgroup        o1,o2,..,oN              comma-separated list of outgroup taxon names (it's just a drawing option!)
  -*site-weights    FILE                     file with MSA column weights (positive integers only!)  

General options:
  -*seed         VALUE                       seed for pseudo-random number generator (default: current time)
  -*pat-comp     on | off                    alignment pattern compression (default: ON)
  -*tip-inner    on | off                    tip-inner case optimization (default: OFF)
  -*site-repeats on | off                    use site repeats optimization, 10%-60% faster than tip-inner (default: ON)
  -*threads      VALUE                       number of parallel threads to use (default: 64)
  -*workers      VALUE                       number of tree searches to run in parallel (default: 1)
  -*simd         none | sse3 | avx | avx2    vector instruction set to use (default: auto-detect).
  -*rate-scalers on | off                    use individual CLV scalers for each rate category (default: ON for >2000 taxa)
  -*force        [ <CHECKS> ]                disable safety checks (please think twice!)

Model options:
  -*model        <name>+G[n]+<Freqs> | FILE  model specification OR partition file
  -*brlen        linked | scaled | unlinked  branch length linkage between partitions (default: scaled)
  -*blmin        VALUE                       minimum branch length (default: 1e-6)
  -*blmax        VALUE                       maximum branch length (default: 100)
  -*blopt        nr_fast    | nr_safe        branch length optimization method (default: nr_fast)
                 nr_oldfast | nr_oldsafe     
  -*opt-model    on | off                    ML optimization of all model parameters (default: ON)
  -*opt-branches on | off                    ML optimization of all branch lengths (default: ON)
  -*prob-msa     on | off                    use probabilistic alignment (works with CATG and VCF)
  -*lh-epsilon   VALUE                       log-likelihood epsilon for optimization/tree search (default: 0.1)

Topology search options:
  -*spr-radius   VALUE                       SPR re-insertion radius for fast iterations (default: AUTO)
  -*spr-cutoff   VALUE | off                 relative LH cutoff for descending into subtrees (default: 1.0)

Bootstrapping options:
  -*bs-trees     VALUE                       number of bootstraps replicates
  -*bs-trees     autoMRE{N}                  use MRE-based bootstrap convergence criterion, up to N replicates (default: 1000)
  -*bs-trees     FILE                        Newick file containing set of bootstrap replicate trees (with -*support)
  -*bs-cutoff    VALUE                       cutoff threshold for the MRE-based bootstopping criteria (default: 0.03)
  -*bs-metric    fbp | tbe                   branch support metric: fbp = Felsenstein bootstrap (default), tbe = transfer distance

EXAMPLES:
  1. Perform tree inference on DNA alignment 
     (10 random + 10 parsimony starting trees, general time-reversible model, ML estimate of substitution rates and
      nucleotide frequencies, discrete GAMMA model of rate heterogeneity with 4 categories):

     ./raxml-ng -*msa testDNA.fa -*model GTR+G


  2. Perform an all-in-one analysis (ML tree search + non-parametric bootstrap) 
     (10 randomized parsimony starting trees, fixed empirical substitution matrix (LG),
      empirical aminoacid frequencies from alignment, 8 discrete GAMMA categories,
      200 bootstrap replicates):

     ./raxml-ng -*all -*msa testAA.fa -*model LG+G8+F -*tree pars{10} -*bs-trees 200


  3. Optimize branch lengths and free model parameters on a fixed topology
     (using multiple partitions with proportional branch lengths)

     ./raxml-ng -*evaluate -*msa testAA.fa -*model partitions.txt -*tree test.tree -*brlen scaled

 -->


<!-- Rules for running RAxML-NG 1.0.1 on Expanse via the CIPRES gateway

All runs are on one standard node of Expanse.

- Ask the user for the following:

  whether the data set has amino acid (AA) data,
  whether the data set has binary (BIN) or multistate (MULTI) data, and
  how many patterns are in the data set.

  If the data set does not contain AA, BIN, or MULTI data, assume that it is DNA.

  Note that the number of patterns and memory requirement can be obtained by making a
  brief run using the -*parse option.
  
- Check whether the analysis is -*all, -*bootstrap, or -*search.

- Specify the number of threads (CIPRES_THREADSPP) and number of workers according
  to the following table.

    Data            Data                        Slurm    Slurm
    type        patterns  Threads  Workers  partition   memory

Analysis doing -*all, -*bootstrap, or -*search

     DNA          <4,000       80       20     shared     154G
     DNA     4,000-7,999      120       20    compute	  243G
     DNA    8,000-39,999      120       10    compute 	  243G
     DNA   40,000-99,999      125        5    compute	  243G
  -> DNA  100,000-499,999      128        2    compute    243G
  -> DNA        >=500,000      128        1    compute    243G

      AA          <1,500       80       20     shared     154G
      AA     1,500-4,999      120       20    compute 	  243G
      AA     5,000-9,999      120       10    compute	  243G
      AA   10,000-39,999      125        5    compute	  243G
   -> AA    40,000-99,999      128        2    compute    243G
   -> AA        >=100,000      128        1    compute    243G

  BIN or         <10,000       80       20     shared     154G
   MULTI        >=10,000      120       10    compute

Any other analysis

     DNA          <4,000        8              shared      15G
     DNA     4,000-9,999       16              shared      30G
     DNA   10,000-59,999       32              shared      61G
     DNA  60,000-299,999       64              shared     123G
     DNA       >=300,000      128             compute                  

      AA          <1,500        8              shared      15G
      AA     1,500-3,999       16              shared      30G
      AA     4,000-9,999       32              shared      61G
      AA   10,000-39,999       48              shared      92G
      AA        >=40,000      128             compute  

  BIN or         <10,000        6              shared      11G
   MULTI        >=10,000       12              shared      23G

 -->
	
 <!-- call the wrapper --> 
					<parameter ishidden="1" type="String">
						<name>raxmlng_1</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "J" &amp;&amp; $select_analysis ne "I"  &amp;&amp;  $select_analysis ne "fb"  &amp;&amp;  $select_analysis ne "rfdist" &amp;&amp; !$fast_version</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"raxml-ng_1.2.1_expanse -msa infile.txt"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!--					<parameter ishidden="1" type="String">
						<name>raxmlng_1b</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "J" &amp;&amp; $select_analysis ne "I"  &amp;&amp;  $select_analysis ne "fb"  &amp;&amp;  $select_analysis ne "rfdist" &amp;&amp; $fast_version</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"raxml-ng_1.1.0.fast_expanse -msa infile.txt"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>-->
					
<!-- -*support 	-f b 	Compute bipartition support for a given reference tree (e.g., best ML tree) using an existing set of replicate trees (e.g., bootstrap trees obtained with -*bootstrap option above). 
		Usage: -*support -*tree bestML.tree -*bs-trees bootstraps.tree  							
								<value>fb</value> -->
<!-- -*bsconverge 	-I 	A posteriori bootstrap convergence test. Usage:	raxml-ng -*bsconverge -*bs-trees bootstraps.tree -*bs-cutoff 0.03								
								<value>I</value> -->							
<!-- -*rfdist 	-f r 	Compute Robinson-Foulds (RF) distance between trees. Usage:-*rfdist -*tree alltrees.nw  
								<value>rfdist</value> </label>	-->
<!-- -*consense 	-J 	Build a consensus tree. Usage:  -*consense MR -*tree alltrees.nw  
								<value>J</value>	 -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng_2</name>
						<attributes>
<!-- -*support; -*consense; -*rfdist; -*bsconverge -->
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "J" || $select_analysis eq "I" || $select_analysis eq "fb" || $select_analysis eq "rfdist" </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"raxml-ng_1.2.1_expanse"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>
<!-- Analysis not -*all, -*bootstrap, or -*search -->
<!-- datatype: not protein, not BIN, not MULTI  -->
<!-- datatype: protein  -->
<!-- datatype: BIN or MULTI  -->

<!-- Analysis doing -*all, -*bootstrap, or -*search -->
<!-- datatype: not protein, not BIN, not MULTI  -->
<!--Data            Data                        Slurm    Slurm
    type        patterns  Threads  Workers  partition   memory

Analysis doing -*all, -*bootstrap, or -*search

     DNA          <4,000       80       20     shared     154G
     DNA     4,000-7,999      120       20    compute
     DNA    8,000-39,999      120       10    compute 
     DNA   40,000-99,999      125        5    compute
     DNA       >=100,000      128        2    compute -->
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &lt; 4000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=80\\n" .
									"mem=154G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp1worker</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &lt; 4000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 20"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>
					
<!--      DNA     4,000-7,999      120       20    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $num_patterns &lt; 8000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=120\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp2workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $num_patterns &lt; 8000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 20"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>
					
<!--      DNA    8,000-39,999      120       10    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp3</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 7999 &amp;&amp; $num_patterns &lt; 40000  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=120\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!--      DNA    8,000-39,999      120       10    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp3workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 7999 &amp;&amp; $num_patterns &lt; 40000  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 10"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>
					
<!--      DNA   40,000-99,999      125        5    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp4</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $num_patterns &lt; 100000  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=125\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>

<!--      DNA   40,000-99,999      125        5    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp4workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $num_patterns &lt; 100000  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 5"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>
					
<!--      DNA       >=100,000      128        2    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp5</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 99999  &amp;&amp; $num_patterns &lt; 500000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=128\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp5workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &lt; 500000 &amp;&amp; $num_patterns &gt; 99999 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 2"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>
					
					<!--      DNA       >=500,000      128        2    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp6</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 499999  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=128\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnp6workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 499999  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 1"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>
					
<!-- Analysis doing -*all, -*bootstrap, or -*search -->					
<!-- datatype: protein  -->
<!--  AA          <1,500       80       20     shared     154G
      AA     1,500-4,999      120       20    compute 
      AA     5,000-9,999      120       10    compute
      AA   10,000-39,999      125        5    compute
      AA        >=40,000      128        2    compute -->
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &lt; 1500 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!--								"jobtype=mpi\\n" . -->
									"threads_per_process=80\\n" .
									"mem=154G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr1workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &lt; 1500 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 20"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>

<!--       AA     1,500-4,999      120       20    compute  -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $num_patterns &lt; 5000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!--								"jobtype=mpi\\n" . -->
									"threads_per_process=120\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr2workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $num_patterns &lt; 5000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 20"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>

<!--       AA     5,000-9,999      120       10    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr3</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 4999 &amp;&amp; $num_patterns &lt; 10000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!--								"jobtype=mpi\\n" . -->
									"threads_per_process=120\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr3workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 4999 &amp;&amp; $num_patterns &lt; 10000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 10"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>
									
<!--       AA   10,000-39,999      125        5    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr4</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 9999 &amp;&amp; $num_patterns &lt; 40000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!--								"jobtype=mpi\\n" . -->
									"threads_per_process=125\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr4workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 9999 &amp;&amp; $num_patterns &lt; 40000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 5"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>
					
<!--       AA        >=40,000      128        2    compute -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr5</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $num_patterns &lt; 100000</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!--								"jobtype=mpi\\n" . -->
									"threads_per_process=128\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr5workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $num_patterns &lt; 100000</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 2"</code>
							</format>
							<group>1</group>
						</attributes>
					</parameter>
					
<!--  -> AA        >=100,000      128        1    compute    243G -->			
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr6</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 99999</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!--								"jobtype=mpi\\n" . -->
									"threads_per_process=128\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainpr6workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 99999</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 1"</code>
							</format>
							<group>1</group>
						</attributes>
					</parameter>
					
<!-- select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &lt; 3999 &amp;&amp; !$more_memory -->
<!-- datatype = multi or bin -->
<!-- 
  BIN or         <10,000       80       20     shared     154G
   MULTI        >=10,000      120       10    compute  -->
   
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainbin1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &lt; 10000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!--								"jobtype=mpi\\n" . -->
									"threads_per_process=80\\n" .
									"mem=154G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainbin1workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &lt; 10000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 20"</code>
							</format>
							<group>1</group>							
						</attributes>
					</parameter>

<!--       MULTI        >=10,000      120       10    compute   -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainbin2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!--								"jobtype=mpi\\n" . -->
									"threads_per_process=120\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainbin2workers</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--workers 10"</code>
							</format>
							<group>1</group>
						</attributes>
					</parameter>
					
<!-- more memory, not protein -->
<!-- not AA          any        1       24       24        1     large-    540G
                                                                 shared 
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainnpmm</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "evaluate" || $select_analysis eq "search" || $select_analysis eq "search1") &amp;&amp; $datatype ne "protein" &amp;&amp; $more_memory</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=24\\n" .
									"threads_per_process=1\\n" .
									"large_data=1\\n" .
									"request_mem=540G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter> -->

<!-- more memory, protein -->
<!--       AA          any        1       48       48        1     large-   1080G
                                                              shared 
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_mainprmm</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "evaluate" || $select_analysis eq "search" || $select_analysis eq "search1") &amp;&amp; $datatype eq "protein" &amp;&amp; $more_memory</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
									"jobtype=mpi\\n" .
									"mpi_processes=48\\n" .
									"threads_per_process=1\\n" .
									"large_data=1\\n" .
									"request_mem=1080G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter> -->

<!-- Any other analysis

     DNA          <4,000        8              shared      15G
     DNA     4,000-9,999       16              shared      30G
     DNA   10,000-59,999       32              shared      61G
     DNA  60,000-299,999       64              shared     123G
     DNA       >=300,000      128             compute                  

      AA          <1,500        8              shared      15G
      AA     1,500-3,999       16              shared      30G
      AA     4,000-9,999       32              shared      61G
      AA   10,000-39,999       48              shared      92G
      AA        >=40,000      128             compute  

  BIN or         <10,000        6              shared      11G
   MULTI        >=10,000       12              shared      23G  -->	
   
   						
<!-- DNA          <4,000        8              shared      15G
     DNA     4,000-9,999       16              shared      30G
     DNA   10,000-59,999       32              shared      61G
     DNA  60,000-299,999       64              shared     123G
     DNA       >=300,000      128             compute        -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_othernp1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &lt; 4000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=8\\n" .
									"mem=15G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!--      DNA     4,000-9,999       16              shared      30G -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_othernp2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $num_patterns &lt; 10000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=16\\n" .
									"mem=30G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>

<!--      DNA   10,000-59,999       32              shared      61G -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_othernp3</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 9999 &amp;&amp; $num_patterns &lt; 60000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=32\\n" .
									"mem=61G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!--      DNA  60,000-299,999       64              shared     123G -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_othernp4</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 59999 &amp;&amp; $num_patterns &lt; 300000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=64\\n" .
									"mem=123G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>

<!--      DNA       >=300,000      128             compute        -->					
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_othernp5</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 299999 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=128\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!--  AA          <1,500        8              shared      15G
      AA     1,500-3,999       16              shared      30G
      AA     4,000-9,999       32              shared      61G
      AA   10,000-39,999       48              shared      92G
      AA        >=40,000      128             compute  -->
      
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_otherpr1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &lt; 1500 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=8\\n" .
									"mem=15G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>      

<!--  AA     1,500-3,999       16              shared      30G -->				
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_otherpr2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp;  $num_patterns &lt; 4000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=16\\n" .
									"mem=30G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter> 
					
<!--  AA     4,000-9,999       32              shared      61G  -->
 					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_otherpr3</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp;  $num_patterns &lt; 10000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=32\\n" .
									"mem=61G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter> 
					
<!--  AA   10,000-39,999       48              shared      92G	 -->
 					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_otherpr4</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 9999 &amp;&amp;  $num_patterns &lt; 40000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=48\\n" .
									"mem=92G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter> 	
					
<!--       AA        >=40,000      128             compute -->
 					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_otherpr5</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=128\\n" .
									"mem=243G\\n" .
									"node_exclusive=1\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter> 
      				
 <!-- BIN or         <10,000        6              shared      11G -->
 					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_otherbin1</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search"  &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &lt; 10000 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=6\\n" .
									"mem=11G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter> 	
					
<!--       MULTI        >=10,000       12              shared      23G  -->
 					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_otherbin2</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999 </code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=12\\n" .
									"mem=23G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter> 		
					
<!-- when the options do not require datatype, or number of patterns -->	
					<parameter ishidden="1" type="String">
						<name>raxmlng__scheduler_otherall</name>
						<attributes>
							<paramfile>scheduler.conf</paramfile>
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "fb" || $select_analysis eq "I" || $select_analysis eq "rfdist"  ||  $select_analysis eq "J" &amp;&amp; !defined $datatype</code>
							</precond>
							<format>
								<language>perl</language>
								<code>
<!-- 								"jobtype=mpi\\n" . -->
									"threads_per_process=8\\n" .
									"mem=15G\\n" .
									"node_exclusive=0\\n" .
									"nodes=1\\n"
								</code>
								</format>
							<group>0</group>
						</attributes>
					</parameter>
					
<!-- End of hidden params Section 1 -->				
<!-- Begin hidden params Section 2 -->
<!-- Option: -*msa FILE (mandatory) RAxML-NG supports alignments in FASTA, PHYLIP and CATG formats.
By default, RAxML-NG will try to automatically detect alignment format based on the file contents. Usually this works just fine, 
but you can also specify the alignment format explicitly with the -*msa-format option.
Evolutionary model -->
					<parameter ismandatory="1" issimple="1" isinput="1" type="InFile">
						<name>infile</name>
						<attributes>
							<prompt>Sequences File (relaxed phylip format) (-s)</prompt>
							<group>1</group>
							<filenames>infile.txt</filenames>
						</attributes>
					</parameter>
									

<!-- 	Only used for the big protein option using 48 cores 				
					
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>force_option</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $more_memory</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"-*force"</code>
							</format>
							<group>1</group>
							<filenames>infile</filenames>
						</attributes>
					</parameter> -->	
<!-- Set the model for Nucleotide sequences  -->
<!--  Option: -*model STRING | FILE (mandatory)

Evolutionary model can be specified globally (i.e., for the whole alignment), 
or multiple models can be selected for different subsets of alignment columns 
(so called partitioned analysis).

Single model

Global per-alignment evolutionary model can be given as a string on the command line. 
Model specification always starts with a substitution matrix name, e.g., GTR for DNA 
data or LG for protein data. Several optional modifiers can be added, separated by 
+ and in arbitrary order. This notation is inspired by, and mostly compatible with,
model specification in the IQ-Tree program (Nguyen et al. 2015).

NOTE: all per-state values (e.g. base frequencies) must be given in the following order:
Defaults
Data type 	Order
DNA 		A C G T
PROTEIN 	A R N D C Q E G H I L K M F P S T W Y V
MULTISTATE 	0 1 2 3 4 5 6 7 8 9 A B C D E F G H I J K L M N O P Q R S T U V W X Y Z ! " # $ % & ' ( ) * + , / : ; < = > @ [ \ ] ^ _ { | } ~
GENOTYPE (diploid unphased) 	A C G T M R W S Y K
(Meaning: A/A C/C G/G T/T A/C A/G A/T C/G C/T G/T)

User-defined state encoding
RAxML-NG allows to define a custom state encoding - that is, a mapping between 
(observed) alignment characters and (internal) model states - via a file in the 
format described below. This format supports ambiguities and synonyms. For instance, 
classical encoding for DNA data can be specified as follows:

19    4
ACGTURYSWKMBDHVN-.?
Ade Cyt Gua Thy
A    1,0,0,0
C    0,1,0,0
G    0,0,1,0
T    0,0,0,1
U    0,0,0,1
R    1,0,1,0
Y    0,1,0,1
S    0,1,1,0
W    1,0,0,1
K    0,0,1,1
M    1,1,0,0
B    0,1,1,1
D    1,0,1,1
H    1,1,0,1
V    1,1,1,0
N    1,1,1,1
-    1,1,1,1
.    1,1,1,1
?    1,1,1,1

All substitution matrices and modifiers are summarized in the following table:

Modifier Possible values

Substitution matrix
DNA data: JC, K80, F81, HKY, TN93ef, TN93, K81, K81uf, TPM2, TPM2uf, TPM3, TPM3uf, TIM1, TIM1uf, TIM2, TIM2uf, TIM3, TIM3uf,TVMef, TVM, SYM, GTR
Protein data*: Blosum62, cpREV, Dayhoff, DCMut, DEN, FLU, HIVb,HIVw, JTT, JTT-DCMut, LG, mtART,mtMAM, mtREV, mtZOA, PMB, rtREV,stmtREV, VT, WAG, LG4M (implies +G4), LG4X (implies +R4), PROTGTR
Binary data (0/1): BIN
Morphological/multistate: MULTIx_MK, MULTIx_GTR (where x = number of states, e.g.: MULTI8_MK for a 8-state model with equal rates) state encoding
Unphased diploid genotypes (10 states): GTJC GTHKY4 GTGTR4 GTGTR

User-defined symmetries: e.g. DNA010010 (equivalent to HKY) or MULTI5_USERabcdeabcde

Fixed user-defined rates: e.g. HKY{1.0/2.5} or GTR{0.5/2.0/1.0/1.2/0.1/1.0} or PROTGTR{rates.txt}. The rates above define upper triangle of the substitution matrix, e.g. for GTR the order is A-C, A-G, A-T, C-G, C-T, G-T

PAML format: e.g. PROTGTR{PAML.txt} (lower triangle of substitution matrix + equilibrium frequencies in a single text file, example)

Stationary frequencies 	
+F or +FC (empirical)
+FO (ML estimate)
+FE (equal)
+FU{f1/f2/../fn} (user-defined: f1 f2 ... fn)
+FU{freqs.txt} (user-defined from file)
Proportion of
invariant sites 	+I or +IO (ML estimate)
+IC (empirical)
+IU{p} (user-defined: p)

Among-site rate heterogeneity model 	
+G (discrete GAMMA with 4 categories, mean category rates, ML estimate of alpha)
+GA (as above, but with median category rates)
+Gn (discrete GAMMA with n categories, ML estimate of alpha)
+Gn{a} (discrete GAMMA with n categories and user-defined alpha a)
+Rn (FreeRate with n categories, ML estimate of rates and weights)
+Rn{r1/r2/../rn}{w1/w2/../wn} (FreeRate with n categories, user-defined rates r1 r2 ... rn and weights w1 w2 ... wn)

Ascertainment bias
correction 	+ASC_LEWIS (Lewis' method)
+ASC_FELS{w} (Felsenstein's method with total number of invariable sites w)
+ASC_STAM{w1/w2/../wn} (Stamatakis' method with per-state invariable site numbers w1 w2 ... wn)
Custom
character-to-state mapping 	+M{statechars}{gapchars} e.g. MULTI6_GTR+M{ABCDEF}{X-?}
+Mi{statechars}{gapchars} same as above, but statechars are case-insensitive
+M{charmap.txt} mapping defined in charmap.txt file (see below)

* see libpll wiki for details & references
Multiple models

Multiple models can be defined in a RAxML-style partition file. Example:

JC+G, p1 = 1-100, 252-400
HKY+F, p2 = 101-180, 251
GTR+I, p3 = 181-250

Here, each line defines a partition and consist of three elements:

    model specification (see above)
    partition name
    range of alignment columns

NOTE: In RAxML, certain model modifiers were global (e.g., GAMMA model of rate heterogeneity), and thus they were specified on the command line and not in partition file. In RAxML-NG, this limitation was lifted, i.e. it is now possible to combine partitions with and without GAMMA, proportion of invariant sites etc. (as in example above). However, this means that RAxML partition files might need to be adjusted for RAxML-NG (e.g., by adding+G for the partitions where GAMMA model of rate heterogeneity should be used).
Branch length linkage -->



<!-- ###################################################################################### -->
<!-- Visible parameters -->
<!-- ###################################################################################### -->

<!-- Parameters with visible controls start here -->
		<parameter type="Float" issimple="1" ismandatory="1">
			<name>runtime</name>
			<attributes>
				<group>1</group>
				<paramfile>scheduler.conf</paramfile>
				<prompt>Maximum Hours to Run (click here for help setting this correctly)</prompt>
					<format>
						<language>perl</language>
						<code>"runhours=$value\\n"</code>
					</format>
					<vdef>
						<value>0.25</value>
					</vdef>
					<comment>
<value>Estimate the maximum time your job will need to run. We recommend testimg initially with a &lt; 0.5hr test run because Jobs set for 0.5 h or less depedendably run immediately in the "debug" queue. 
Once you are sure the configuration is correct, you then increase the time. The reason is that jobs &gt; 0.5 h are submitted to the "normal" queue, where jobs configured for 1 or a few hours times may
run sooner than jobs configured for the full 168 hours. 
</value>

					</comment>
					<ctrls>
						<ctrl>
							<message>Maximum Hours to Run must be 168 or less</message>
							<language>perl</language>
							<code>$runtime &gt; 168.0 </code>
						</ctrl>
<!--  					<ctrl>
						<message>Maximum Hours for a large memory run must be 48 or less</message>
						<language>perl</language>
						<code>$runtime &gt; 48.0 &amp;&amp; $more_memory</code>
					</ctrl>-->
					<ctrl>
						<message>Maximum Hours to Run must be greater than 0.1 </message>
						<language>perl</language>
						<code>$runtime &lt; 0.1</code>
					</ctrl>
				</ctrls>
<!--  Analysis doing -*all, -*bootstrap, or -*search -->

<!-- DNA          <4,000       80       20     shared     154G
     DNA     4,000-7,999      120       20    compute
     DNA    8,000-39,999      120       10    compute 
     DNA   40,000-99,999      125        5    compute
     DNA       >=100,000      128        2    compute -->
 
				<warns>
					<warn>
						<message>The faster version runs about 1.5x faster, using weaker constraints. Please see https://www.biorxiv.org/content/10.1101/2022.07.13.499893v1</message>
						<language>perl</language>
						<code>$fast_version &amp;&amp; $select_analysis ne "J" &amp;&amp; $select_analysis ne "I"  &amp;&amp;  $select_analysis ne "fb"  &amp;&amp;  $select_analysis ne "rfdist"</code>
					</warn>
					<warn>
						<message>You can run your analysis 1.5x faster using the faster version. It uses weaker constraints. Please see https://www.biorxiv.org/content/10.1101/2022.07.13.499893v1</message>
						<language>perl</language>
						<code>!$fast_version &amp;&amp; $select_analysis ne "J" &amp;&amp; $select_analysis ne "I"  &amp;&amp;  $select_analysis ne "fb"  &amp;&amp;  $select_analysis ne "rfdist"</code>
					</warn>
					<warn>
						<message>The job will run on 80 processors as configured. If it runs for the entire configured time, it will consume 80 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &lt; 4000 </code>
					</warn>
	  				<warn>
						<message>The job will run on 120 processors as configured. If it runs for the entire configured time, it will consume 120 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $num_patterns &lt; 8000 </code>
					</warn>
					<warn>
						<message>The job will run on 120 processors as configured. If it runs for the entire configured time, it will consume 120 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 7999 &amp;&amp; $num_patterns &lt; 40000  </code>
					</warn>
					<warn>
						<message>The job will run on 125 processors as configured. If it runs for the entire configured time, it will consume 125 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $num_patterns &lt; 100000  </code>
					</warn>
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 99999  </code>
					</warn>
					<warn>
						<message>WARNING: This job will require 3,000-6,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $runtime &gt;= 24 &amp;&amp; $runtime &lt; 48</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 6,000-9,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $runtime &gt;= 48 &amp;&amp; $runtime &lt; 72</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 9,000-12,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $runtime &gt;= 72 &amp;&amp; $runtime &lt; 96</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 12,000-15,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $runtime &gt;= 96 &amp;&amp; $runtime &lt; 120</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 15,000-18,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $runtime &gt;= 120 &amp;&amp; $runtime &lt; 144</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 18,000-21,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $runtime &gt;= 144 &amp;&amp; $runtime &lt;= 168</code>
					</warn>
					
<!--  AA          <1,500       80       20     shared     154G
      AA     1,500-4,999      120       20    compute 
      AA     5,000-9,999      120       10    compute
      AA   10,000-39,999      125        5    compute
      AA        >=40,000      128        2    compute -->
					<warn>
						<message>The job will run on 80 processors as configured. If it runs for the entire configured time, it will consume 80 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &lt; 1500 </code>
					</warn>
					<warn>
						<message>The job will run on 120 processors as configured. If it runs for the entire configured time, it will consume 120 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $num_patterns &lt; 5000 </code>
					</warn>
					<warn>
						<message>The job will run on 120 processors as configured. If it runs for the entire configured time, it will consume 120 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 4999 &amp;&amp; $num_patterns &lt; 10000 </code>
					</warn>
					<warn>
						<message>The job will run on 125 processors as configured. If it runs for the entire configured time, it will consume 125 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 9999 &amp;&amp; $num_patterns &lt; 40000 </code>
					</warn>
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 </code>
					</warn>
					<warn>
						<message>WARNING: This job will require 3,000-6,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $runtime &gt;= 24 &amp;&amp; $runtime &lt; 48 </code>
					</warn>
					<warn>
						<message>WARNING: This job will require 6,000-9,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $runtime &gt;= 48 &amp;&amp; $runtime &lt; 72</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 9,000-12,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $runtime &gt;= 72 &amp;&amp; $runtime &lt; 96</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 12,000-15,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $runtime &gt;= 96 &amp;&amp; $runtime &lt; 120</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 15,000-18,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $runtime &gt;= 120 &amp;&amp; $runtime &lt; 144</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 18,000-21,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $runtime &gt;= 144 &amp;&amp; $runtime &lt;= 168</code>
					</warn>
					
<!-- BIN or         <10,000       80       20     shared     154G
     MULTI        >=10,000      120       10    compute -->
   					<warn>
						<message>The job will run on 80 processors as configured. If it runs for the entire configured time, it will consume 80 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &lt; 10000 </code>
					</warn>
					<warn>
						<message>The job will run on 120 processors as configured. If it runs for the entire configured time, it will consume 120 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999 </code>
					</warn>
					<warn>
						<message>WARNING: This job will require 3,000-6,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999  &amp;&amp; $runtime &gt;= 24 &amp;&amp; $runtime &lt; 48</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 6,000-9,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999  &amp;&amp; $runtime &gt;= 48 &amp;&amp; $runtime &lt; 72</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 9,000-12,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999  &amp;&amp; $runtime &gt;= 72 &amp;&amp; $runtime &lt; 96</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 12,000-15,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999  &amp;&amp; $runtime &gt;= 96 &amp;&amp; $runtime &lt; 120</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 15,000-18,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999  &amp;&amp; $runtime &gt;= 120 &amp;&amp; $runtime &lt; 144</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 18,000-21,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>($select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "search") &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999  &amp;&amp; $runtime &gt;= 144 &amp;&amp; $runtime &lt;= 168</code>
					</warn> 
					
<!--  Any other analysis -->
<!-- DNA          <4,000        8              shared      15G
     DNA     4,000-9,999       16              shared      30G
     DNA   10,000-59,999       32              shared      61G
     DNA  60,000-299,999       64              shared     123G
     DNA       >=300,000      128             compute       -->        
     				<warn>
						<message>The job will run on 8 processors as configured. If it runs for the entire configured time, it will consume 8 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &lt; 4000 </code>
					</warn>
					<warn>
						<message>The job will run on 16 processors as configured. If it runs for the entire configured time, it will consume 16 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $num_patterns &lt; 10000 </code>
					</warn>
					<warn>
						<message>The job will run on 32 processors as configured. If it runs for the entire configured time, it will consume 32 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 9999 &amp;&amp; $num_patterns &lt; 60000 </code>
					</warn>
					<warn>
						<message>The job will run on 64 processors as configured. If it runs for the entire configured time, it will consume 64 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 59999 &amp;&amp; $num_patterns &lt; 300000 </code>
					</warn>  
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 299999 </code>
					</warn>
					<warn>
						<message>WARNING: This job will require 3,000-6,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 299999 &amp;&amp; $runtime &gt;= 24 &amp;&amp; $runtime &lt; 48</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 6,000-9,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 299999 &amp;&amp; $runtime &gt;= 48 &amp;&amp; $runtime &lt; 72</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 9,000-12,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 299999 &amp;&amp; $runtime &gt;= 72 &amp;&amp; $runtime &lt; 96</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 12,000-15,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 299999 &amp;&amp; $runtime &gt;= 96 &amp;&amp; $runtime &lt; 120</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 15,000-18,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 299999 &amp;&amp; $runtime &gt;= 120 &amp;&amp; $runtime &lt; 144</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 18,000-21,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype ne "protein" &amp;&amp; $datatype ne "bin" &amp;&amp; $datatype ne "multi" &amp;&amp; $num_patterns &gt; 299999 &amp;&amp; $runtime &gt;= 144 &amp;&amp; $runtime &lt;= 168</code>
					</warn>   
 <!-- AA          <1,500        8              shared      15G
      AA     1,500-3,999       16              shared      30G
      AA     4,000-9,999       32              shared      61G
      AA   10,000-39,999       48              shared      92G
      AA        >=40,000      128             compute   -->
      				<warn>
						<message>The job will run on 8 processors as configured. If it runs for the entire configured time, it will consume 8 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &lt; 1500 </code>
					</warn>
					<warn>
						<message>The job will run on 16 processors as configured. If it runs for the entire configured time, it will consume 16 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 1499 &amp;&amp; $num_patterns &lt; 4000 </code>
					</warn>
					<warn>
						<message>The job will run on 32 processors as configured. If it runs for the entire configured time, it will consume 32 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 3999 &amp;&amp; $num_patterns &lt; 10000 </code>
					</warn>
					<warn>
						<message>The job will run on 48 processors as configured. If it runs for the entire configured time, it will consume 48 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 9999 &amp;&amp; $num_patterns &lt; 40000 </code>
					</warn>
					<warn>
						<message>The job will run on 128 processors as configured. If it runs for the entire configured time, it will consume 128 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 </code>
					</warn>
					<warn>
						<message>WARNING: This job will require 3,000-6000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $runtime &gt;= 24 &amp;&amp; $runtime &lt; 48</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 6,000-9000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $runtime &gt;= 48 &amp;&amp; $runtime &lt; 72</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 9,000-12000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $runtime &gt;= 72 &amp;&amp; $runtime &lt; 96</code>
					</warn> 
					<warn>
						<message>WARNING: This job will require 12,000-15,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $runtime &gt;= 96 &amp;&amp; $runtime &lt; 120</code>
					</warn> 		
					<warn>
						<message>WARNING: This job will require 15,000-18,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $runtime &gt;= 120 &amp;&amp; $runtime &lt; 144</code>
					</warn>
					<warn>
						<message>WARNING: This job will require 18,000-21,000 CPU hours if it runs for the entire configured time; are you sure you want to do this?</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; $datatype eq "protein" &amp;&amp; $num_patterns &gt; 39999 &amp;&amp; $runtime &gt;= 144 &amp;&amp; $runtime &lt;= 168</code>
					</warn>   
 <!--   BIN or         <10,000        6              shared      11G
   MULTI        >=10,000       12              shared      23G -->	
					<warn>
						<message>The job will run on 6 processors as configured. If it runs for the entire configured time, it will consume 6 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search"  &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &lt; 10000 </code>
					</warn>
					<warn>
						<message>The job will run on 12 processors as configured. If it runs for the entire configured time, it will consume 12 x $runtime cpu hours</message>
						<language>perl</language>
						<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp;  $select_analysis ne "all" &amp;&amp; $select_analysis ne "bootstrap" &amp;&amp; $select_analysis ne "search" &amp;&amp; ($datatype eq "bin" || $datatype eq "multi") &amp;&amp; $num_patterns &gt; 9999 </code>
					</warn>	
<!-- $select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; -->
					<warn>
						<message>The job will run on 12 processors as configured. If it runs for the entire configured time, it will consume 12 x $runtime cpu hours</message>
						<language>perl</language>
						<code>($select_analysis eq "fb" || $select_analysis eq "I" || $select_analysis eq "rfdist"  ||  $select_analysis eq "J") &amp;&amp; !defined $datatype &amp;&amp; !defined $num_patterns</code>
					</warn>	
				</warns>
			</attributes>
		</parameter>
			
<!-- select the analysis RAXML-NG-->	
<!-- RAxML-NG supports several types of analysis, which can be selected by specifying a corresponding command:
Command 	RAxML 8.x equivalent 	Meaning

* Unlike in RAxML 8.x, this command will perform 'slow' bootstrapping procedure. -->
			
					<parameter ismandatory="1"  issimple="1"  type="Excl">
						<name>select_analysis</name>
						<attributes>
							<prompt>Select the Analysis Type</prompt>
							<vlist>
<!-- -*parse 	N/A 	Parse alignment, compress patterns and create binary MSA file -->	
								<value>parse</value>
								<label>Check input files and settings and count alignment patterns (--parse)</label>
								
<!-- -*search 	-f d 	Run topology search to find the best-scoring ML tree (default) -->
								<value>search</value>
								<label>Search for best-scoring ML tree with 10 random and 10 parsimony starting trees by default (--search)</label>
																
<!-- -*all 	-f a* 	Combined tree search and bootstrapping analysis; bootstrap support values will be plotted onto the best-scoring ML tree. -->
								<value>all</value>
								<label>All-In-One: ML tree search and slow bootstrapping (--all)</label>
								
<!-- -*bootstrap 	-b 	Run non-parametric bootstrap analysis (equivalent to 'slow' bootstrapping in RAxML). Number of bootstrap replicates and other parameters can be changed with respective options. -->			
								<value>bootstrap</value>
								<label>Bootstrap: Run slow bootstrapping without ML tree search (--bootstrap)</label>

<!-- -*evaluate 	-f e 	Optimize model parameters and/or branch lengths on a fixed tree topology 
raxml-ng -evaluate -msa <ALIGNMENT> -threads <N> -model <MODEL> -tree bestML.tree -prefix <PREFIX -->
								<value>evaluate</value>
								<label>Evaluate log-likelihood of a given tree with model optimization (--evaluate)</label>

<!-- -*check 	-f c 	Check alignment file and remove any columns consisting entirely of gaps -->
								<value>fc</value>
								<label>Fast Check input files without pattern compression (--check)</label>
																
<!-- FAST SEARCH for best-scoring ML tree with 1 random starting tree by default (-*search1) -->
								<value>search1</value>
								<label>Fast Search for best-scoring ML tree with 1 random starting tree by default (--search1)</label>	

<!-- -*loglh 	N/A 	Compute log-likelihood of a given tree without any optimization. -->
								<value>loglh</value>
								<label>Compute log-likelihood of a given tree with fixed model parameters (--loglh)</label>	

<!-- -*support 	-f b 	Compute bipartition support for a given reference tree (e.g., best ML tree) using an existing set of replicate trees (e.g., bootstrap trees obtained with -*bootstrap option above). 
		Usage: -*support -*tree bestML.tree -*bs-trees bootstraps.tree --> 							
								<value>fb</value>
								<label>Support value mapping from existing set of bootstrap trees (--support)</label>
<!-- -*bsconverge 	-I 	A posteriori bootstrap convergence test. Usage:	raxml-ng -*bsconverge -*bs-trees bootstraps.tree -*bs-cutoff 0.03-->								
								<value>I</value>
								<label>Bootstopping: Test bootstrap convergence a posteriori (--bsconverge)</label>	
<!-- -*ancestral 	-f A 	Marginal ancestral state reconstruction. Usage: raxml-ng -ancestral -msa ali.fa -tree best.tre -model HKY -prefix ASR-->								
								<value>fA</value>
								<label>Ancestral state reconstruction on a given tree (--ancestral)</label>

<!-- -*rfdist 	-f r 	Compute Robinson-Foulds (RF) distance between trees. Usage:-*rfdist -*tree alltrees.nw  -->
								<value>rfdist</value>
								<label>RF: Compute pair-wise Robinson-Foulds distances between trees (--rfdist)</label>	

<!-- -*consense 	-J 	Build a consensus tree. Usage:  -*consense MR -*tree alltrees.nw  -->
								<value>J</value>				
								<label>Consensus: Build strict or majority rule consensus tree (--consense)</label>
<!-- -*start 	-y 	Generate parsimony/random starting trees and exit  -->															
								<value>y</value>
								<label>Generate parsimony starting tree only (--start)</label>
<!-- -*bsmsa 	-f j 	Generate bootstrap replicate alignments. Usage: -*bsmsa  -*bs-trees 100 -->
								<value>fJ</value>
								<label>Replicate alignment generation for bootstrapping (--bsmsa)</label>
								
<!-- -*terrace 	N/A 	Check whether a tree lies on a phylogenetic terrace.  Usage:  -*terrace -*tree best.tre  -->
								<value>terrace</value>
								<label>Terrace: Check whether a tree lies on a phylogenetic terrace (--terrace)</label>

<!-- -*SITE-LH: Print per-site log-likelihood  (-*sitelh) New command syntax identical to -*evaluate, i.e. requires input trees:
raxml-ng -*sitelh -*tree best.tre 
-->
								<value>sitelh</value>
								<label>Site-LH: Print per-site log-likelihood (--sitelh)</label>
							</vlist>
							<flist>
								<value>all</value>
								<code>"--all"</code>
								<value>bootstrap</value>
								<code>"--bootstrap"</code>
								<value>fc</value>
								<code>"--check"</code>
								<value>search</value>
								<code>"--search"</code>	
								<value>search1</value>
								<code>"--search1"</code>
<!-- -support -->						
								<value>fb</value>
								<code>"--support --tree infile.txt --bs-trees bootstraps.tre "</code>								
								<value>fA</value>
								<code>"--ancestral --tree best.tre"</code>
								<value>fJ</value>
								<code>"--bsmsa"</code>	
								<value>evaluate</value>
								<code>"--evaluate --tree best.tre"</code>
								<value>loglh</value>
								<code>"--loglh --tree best.tre"</code>
								<value>parse</value>
								<code>"--parse"</code>
<!-- -rfdist  -->
								<value>rfdist</value>
								<code>"--rfdist --tree infile.txt"</code>
<!-- -bsconverge -->																					
								<value>I</value>
								<code>"--bsconverge --bs-trees infile.txt"</code>
<!-- consense THIS IS IDOSYNCRATIC, IN NOT HAVING A COMMAND HERE. BUT ITS OK. 
specify_consensethresh2 IS WHERE THE COMMAND IS CREATED. iTS A HIDDEN PARAM BELOW.
It uses the main input only, infile.txt -->
								<value>J</value>
								<code>""</code>														
								<value>y</value>
								<code>"--start"</code>
								<value>terrace</value>
								<code>"--terrace --tree best.tre"</code>
								<value>sitelh</value>
								<code>"--sitelh --tree best.tre"</code>
							</flist>
							<vdef>
								<value>search</value>
							</vdef>
							<ctrls>
<!-- If analysis type in [-*support, -*bsconverge, -*rfdist, -*consense] then  following fields must be additionally disabled:

- Simple Parameters: Constraint tree, Sequence Type, Number of patterns
- Substitution Matrix Options: ALL
- Among Site Rate Heterogeneity Options: ALL
- Model Options: ALL
- Ascertainment Bias Configuration: ALL
- Starting Tree Options: Number of parsimony starting trees,  Number of random starting trees, Upload a custom starting tree
 -->
<!-- 						<ctrl>
									<message>To use the -*all option, please select Rapid Bootstrapping (-x)</message>
									<language>perl</language>
									<code>$choose_bootstrap ne "x" &amp;&amp; $select_analysis eq "fa"</code>
								</ctrl>  -->
								<ctrl>
									<message>To use the --ancestral option please specify a best tree</message>
									<language>perl</language>
									<code> $select_analysis eq "fA" &amp;&amp; !defined $besttree_upload</code>
								</ctrl>
<!--							<ctrl>
									<message>To use the -*bsmsa option, please specify a tree with "-t"</message>
									<language>perl</language>
									<code>$select_analysis eq "fJ" &amp;&amp; !defined $treetop</code>
								</ctrl> -->
								<ctrl>
									<message>To use the --evaluate option, please specify a best ML tree</message>
									<language>perl</language>
									<code>$select_analysis eq "fe" &amp;&amp; !defined $treetop</code>
								</ctrl>
<!-- 							<ctrl>
									<message>In order to use the a posteriori bootstrapping option (-*bsconverge), you must supply a file with topologies for a posteriori bootstopping (-z)</message>
									<language>perl</language>
									<code>$select_analysis eq "I" &amp;&amp; !defined $aposterior_topologies &amp;&amp; !defined $bunchotops</code>
								</ctrl>  -->
								<ctrl>
									<message>Sorry, you cant use the --start option and provide a starting tree using -t.</message>
									<language>perl</language>
									<code>$select_analysis eq "y" &amp;&amp; defined $treetop</code>
								</ctrl>
							</ctrls>
							<group>20</group>
							<comment>
								<value>--search is the default RAxML tree search algorithm and is substantially faster than the original search algorithm. 
								It takes some shortcuts, but yields trees that are almost as good as the ones obtained from the full search algorithm.</value>
							</comment>
							<comment>
								<value>When --support is specified, RAxML draws the bipartitions using a bunch of topologies (typically boot-strapped trees) specified with -z onto a single tree topology specified by -t (typically the best-scoring ML tree). </value>
							</comment>
							<comment>
								<value>When --ancestral is specified, RAxML computes marginal ancestral states/sequences on a given, fixed,and rooted reference
							tree. If you don't know what marginal ancestral states are please read  Ziheng Yang's book on Computational Molecular Evolution.. </value>
							</comment>
							<comment>
								<value>The --start option computes a randomized parsimony starting tree with RAxML and not execute an ML analysis of the tree specify --start. The program will exit after computation of the starting tree. This option can be useful if you want to assess the impact of randomized MP and Neighbor Joining starting trees on your search algorithm. They can also be used e.g. as starting trees for Derrick Zwickls GARLI program for ML inferences, which needs comparatively good starting trees to work well above approximately 500 taxa. </value>
							</comment>
						</attributes>
					</parameter>

<!-- add in the option to run fast version 
					<parameter issimple="1" type="Switch">
						<name>fast_version</name>
						<attributes>
							<prompt>Run the fast version of RAXMLNG</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "J" &amp;&amp; $select_analysis ne "I"  &amp;&amp;  $select_analysis ne "fb"  &amp;&amp;  $select_analysis ne "rfdist"</code>
							</precond>
							<group>0</group>
						</attributes>
					</parameter>		-->
					
					
<!-- consOption: -*tree-constraint FILE

You can specify a constraint tree to e.g. enforce monophyly of certain groups (equivalent to the -g option in RAxML8). 
If the constraint tree is comprehensive (i.e., it includes all taxa found in the MSA), 
then RAxML will simply resolve polytomies in the way that maximizes the likelihood. 
Conversely, if some taxa are missing from the constraint, they will be placed freely 
in the resulting ML tree.
Outgroup rootingtraint (-g) -->
		
					<parameter type="InFile" issimple="1">
						<name>constraint</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
							</precond>
							<prompt>Constraint tree (--tree-constraint)</prompt>
							<filenames>constraint.tre</filenames>
							<format>
								<language>perl</language>
								<code>(defined $value) ? "--tree-constraint constraint.tre" : ""</code>
							</format>
							<group>20</group>
							<comment>
<value> This option allows you to specify an incomplete or comprehensive multifurcating constraint tree for the RAxML
search in NEWICK format. Initially, multifurcations are resolved randomly. If the tree is incomplete (does not contain
all taxa) the remaining taxa are added by using the MP criterion. Once a comprehensive (containing all taxa) bifurcating
tree is computed, it is further optimized under ML respecting the given constraints. Important: If you specify a 
non-comprehensive constraint, e.g., a constraint tree that does not contain all taxa, RAxML will assume that any taxa
that not found in the constraint topology are unconstrained, i.e., these taxa can be placed in any part of the tree.  As
an example consider an alignment with 10 taxa: Loach, Chicken, Human, Cow, Mouse, Whale, Seal, Carp, Rat, Frog.  If, for
example you would like Loach, Chicken, Human, Cow to be monophyletic you would specify the constraint tree as follows: </value>
<value> ((Loach, Chicken, Human, Cow),(Mouse, Whale, Seal, Carp, Rat, Frog)); </value>
<value> Moreover, if you would like Loach, Chicken, Human, Cow to be monophyletic and in addition Human, Cow to be 
monophyletic within that clade you could specify: </value>
<value> ((Loach, Chicken, (Human, Cow)),(Mouse, Whale, Seal, Carp, Rat, Frog)); </value>
<value> If you specify an incomplete constraint: </value>
<value> ((Loach, Chicken, Human, Cow),(Mouse, Whale, Seal, Carp)); </value>
<value> the two groups Loach, Chicken, Human, Cow and Mouse, Whale, Seal, Carp will be monophyletic, while Rat and Frog can
end up anywhere in the tree.  </value>
				</comment>
						</attributes>
					</parameter>
				
					<parameter type="Excl" issimple="1" ismandatory="1">
						<name>datatype</name>
						<attributes>
							<prompt>Sequence Type</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
							</precond>
							<vlist>
								<value>protein</value>
								<label>Protein</label>
								<value>dna</value>
								<label>Nucleotide</label>
								<value>bin</value>
								<label>Binary data</label>
								<value>multi</value>
								<label>Morphological/multistate</label>
								<value>unphased</value>
								<label>Unphased diploid genotypes</label>
							</vlist>
							<vdef>
								<value>dna</value>
							</vdef>
						</attributes>
					</parameter>	
					
					<parameter type="Integer" issimple="1" ismandatory="1">
						<name>num_patterns</name>
						<attributes>
							<prompt>Number of patterns in your data set</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
							</precond>
							<vdef>
							<value>1000</value>
							</vdef>
							<ctrls>
 								<ctrl>
									<message>Please specify the number of patterns in your data set. You can make a quick run to determine the correct value.</message>
									<language>perl</language>
									<code>!defined $num_patterns</code>
								</ctrl> 
							</ctrls> 
							<comment>
<value>						Knowing the number of characters in your dataset helps us determine the most efficient way to run raxml.
						The number of patterns is the number of unique columns in the multiple sequence alignment matrix. You can get this number from the output of the intermediate results once a job begins. Entering the number of characters per taxon in your matirx, or 1000 as the number of patterns is an ok start.
						Look at the intermediate results, and see if that is reasonably close. If it is not, kill the job, and adjust the number.
</value>					
							</comment>
						</attributes>
					</parameter>
<!-- Bootstrapping options:
  -*bs-trees     VALUE                       number of bootstraps replicates
  -*bs-trees     autoMRE{N}                  use MRE-based bootstrap convergence criterion, up to N replicates (default: 1000)
  -*bs-trees     FILE                        Newick file containing set of bootstrap replicate trees (with -*support)
  -*bs-cutoff    VALUE                       cutoff threshold for the MRE-based bootstopping criteria (default: 0.03)
  -*bs-metric    fbp | tbe                   branch support metric: fbp = Felsenstein bootstrap (default), tbe = transfer distance
 -->
 <!-- choose automre or not auto mre -->	
					<parameter issimple="1" type="Switch">
						<name>specify_typebootstraps</name>
						<attributes>
							<prompt>Use autoMRE bootstopping</prompt>
 							<precond>
								<language>perl</language>
								<code>$select_analysis eq "all" || $select_analysis eq "bootstrap"</code>
							</precond>
							<vdef>
								<value>1</value>
							</vdef>
						</attributes>
					</parameter>
					
 					<parameter issimple="1" type="Integer">
						<name>specify_bootstraps</name>
						<attributes>
							<prompt>Specify the number of bootstraps</prompt>
 							<precond>
								<language>perl</language>
								<code>$select_analysis eq "fJ" || $select_analysis eq "all" || $select_analysis eq "bootstrap"</code>
							</precond>
							<vdef>
								<value>1000</value>
							</vdef>
							<group>20</group>
							<ctrls>
								<ctrl>
									<message>Please specify the number of bootstraps</message>
									<language>perl</language>
									<code>($select_analysis eq "fJ" || $select_analysis eq "all" || $select_analysis eq "bootstrap") &amp;&amp; !defined $specify_bootstraps</code>
								</ctrl>		
								<ctrl>
									<message>Sorry, explicit bootstraps cannot exceed 500, if you need more, please use the autoMRE bootstopping option</message>
									<language>perl</language>
									<code>!$specify_typebootstraps &amp;&amp; $specify_bootstraps &gt; 500 </code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter>
					
					<parameter issimple="1" ishidden="1" type="Integer">
						<name>specify_mrebootstraps</name>
						<attributes>
 							<precond>
								<language>perl</language>
								<code>$specify_typebootstraps &amp;&amp; ($select_analysis eq "all" || $select_analysis eq "bootstrap")</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--bs-trees autoMRE{$specify_bootstraps}"</code>
							</format>
						</attributes>
					</parameter>
					
					<parameter issimple="1" ishidden="1" type="Integer">
						<name>specify_nonmrebootstraps</name>
						<attributes>
 							<precond>
								<language>perl</language>
								<code>!$specify_typebootstraps &amp;&amp; ($select_analysis eq "fJ" ||$select_analysis eq "all" || $select_analysis eq "bootstrap")</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--bs-trees $specify_bootstraps"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter>
											
					<parameter issimple="1" type="Float">
						<name>specify_bscutoff</name>
						<attributes>
							<prompt>Specify the bootstrap cutoff value</prompt>
 							<precond>
								<language>perl</language>
								<code>$select_analysis eq "I" || $select_analysis eq "all" || $select_analysis eq "bootstrap"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>$specify_bscutoff ne $vdef ? "--bs-cutoff $specify_bscutoff":"" </code>
							</format>
							<vdef>
								<value>0.3</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please specify the bootstrap cutoff value</message>
									<language>perl</language>
									<code>$select_analysis eq "I" &amp;&amp; !defined $specify_bscutoff</code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter>
																			
					<parameter issimple="1" type="Excl">
						<name>specify_bsmetric</name>
						<attributes>
							<prompt>Specify the branch support metric (bs-metric)</prompt>
 							<precond>
								<language>perl</language>
								<code>$select_analysis eq "fJ" ||$select_analysis eq "all" || $select_analysis eq "bootstrap" || $select_analysis eq "fb" </code>
							</precond>
							<vlist>
								<value>fbp</value>
								<label>Felsenstein bootstrap</label>
								<value>tbe</value>
								<label>Transfer distance</label>
								<value>fbp,tbe</value>
								<label>Both</label>
							</vlist>
							<format>
								<language>perl</language>
								<code>($value ne $vdef) ? "--bs-metric $value":"" </code>
							</format>
							<group>20</group>
							<vdef>
								<value>fbp</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Specify the branch support metric</message>
									<language>perl</language>
									<code>($select_analysis eq "fJ" ||$select_analysis eq "all" || $select_analysis eq "bootstrap") &amp;&amp; !defined $specify_bsmetric</code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter>

<!-- With -*opt-model on/off you can enable/disable model parameter optimization. 
With -*opt-branches on/off you can enable/disable branch length optimization. -->
					<parameter issimple="1" type="Switch">
						<name>enable_modelparamopt</name>
						<attributes>
							<prompt>Enable model parameter optimization</prompt>
 							<precond>
								<language>perl</language>
								<code>$select_analysis eq "evaluate" </code>
							</precond>
							<format>
								<language>perl</language>
								<code>($value) ? "--opt-model on":"--opt-model off" </code>
							</format>
							<vdef>
								<value>1</value>
							</vdef>
							<group>20</group>
						</attributes>
					</parameter>
					
					<parameter issimple="1" type="Switch">
						<name>enable_brlopt</name>
						<attributes>
							<prompt>Enable branch length optimization</prompt>
 							<precond>
								<language>perl</language>
								<code>$select_analysis eq "evaluate" </code>
							</precond>
							<format>
								<language>perl</language>
								<code>($value) ? "--opt-branches on":"--opt-branches off" </code>
							</format>
							<vdef>
								<value>1</value>
							</vdef>
							<group>20</group>
						</attributes>
					</parameter>
					
<!-- Option: -*outgroup o1,o2,..,oN

You can specify an outgroup which RAxML-NG will use to root the inferred ML tree. It can be a single taxon (-*outgroup Human) or a list of taxa which form a monophyletic group (-*outgroup Human,Chimp,Gorilla).

Please note that outgroup rooting is just a drawing option and will not affect tree inference process in any way! -->
					<parameter type="String" issimple="1">
						<name>outgroup</name>
						<attributes>
							<prompt>Outgroup (one or more comma-separated outgroups, see comment for syntax)</prompt>
							<format>
								<language>perl</language>
								<code>(defined $value)? "--outgroup $value":""</code>
							</format>
							<group>20</group>
							<comment>
<value>The correct syntax for the box is outgroup1,outgroup2,outgroupn. If white space is introduced (e.g. outgroup1, outgroup2, outgroupn) the program will fail with the message
"Error, you must specify a model of substitution with the '-m' option"
</value>					
							</comment>
						</attributes>
					</parameter>
									
<!-- -prefix argument to specify output file prefix is required -->
					<parameter issimple="1" type="String">
					<name>outprefix</name>
					<attributes>
						<prompt>Prefix for Output</prompt>
						<format>
							<language>perl</language>
							<code>defined $value ? "--prefix $value":""</code>
						</format>
						<group>20</group>
						</attributes>
					</parameter>	

<!-- -set a seed value -->
					<parameter issimple="1" type="Integer">
					<name>specify_seed</name>
					<attributes>
						<prompt>Specify a value for the seed (--seed)</prompt>
						<format>
							<language>perl</language>
							<code>defined $value ? "--seed $value":""</code>
						</format>
						<group>20</group>
						</attributes>
					</parameter>						
							
<!-- more memory flag 
		<parameter type="Switch" issimple="1" >
			<name>more_memory</name>
			<attributes>
				<prompt>I need more memory</prompt>
			</attributes>
		</parameter>-->
		
<!-- #################### MODEL OPTIONS #################################### -->	
<!-- 
DNA data: JC, K80, F81, HKY, TN93ef, TN93, K81, K81uf, TPM2, TPM2uf, TPM3, TPM3uf, TIM1, TIM1uf, TIM2, TIM2uf, TIM3, TIM3uf,TVMef, TVM, SYM, GTR
Protein data*: Blosum62, cpREV, Dayhoff, DCMut, DEN, FLU, HIVb,HIVw, JTT, JTT-DCMut, LG, mtART,mtMAM, mtREV, mtZOA, PMB, rtREV,stmtREV, VT, WAG, LG4M (implies +G4), LG4X (implies +R4), PROTGTR
Binary data (0/1): BIN
Morphological/multistate: MULTIx_MK, MULTIx_GTR (where x = number of states, e.g.: MULTI8_MK for a 8-state model with equal rates) state encoding
Unphased diploid genotypes (10 states): GTJC GTHKY4 GTGTR4 GTGTR -->
			
<parameter type="Paragraph">
	<paragraph>
		<name>model_opts</name>
		<prompt>Substitution Matrix Options</prompt>
		<parameters>
		
		<!-- dna model-->		            		
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; ($ratehet_model eq "+G" || $ratehet_model eq "+GA" || !defined $ratehet_model) &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable$ascl$ratehet_model$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_modelb</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; ($ratehet_model eq "+G" || $ratehet_model eq "+GA" || !defined $ratehet_model) &amp;&amp; defined $ascf &amp;&amp; !defined $ascs  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_FELS{$ascf}$ratehet_model$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_modelc</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; ($ratehet_model eq "+G" || $ratehet_model eq "+GA" || !defined $ratehet_model) &amp;&amp; !defined $ascf &amp;&amp; defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_STAM{$ascs}$ratehet_model$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
										
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model2</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Gn"  &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable$ascl+G$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter>
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model2b</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Gn"  &amp;&amp; defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_FELS{$ascf}+G$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter>
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model2c</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Gn"  &amp;&amp; !defined $ascf &amp;&amp; defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_STAM{$ascs}+G$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter>
<!-- +ASC_FELS{$ascf} -->
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model3</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Gna"  &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable$ascl+G$num_categories{$specify_alpha}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model3b</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Gna"  &amp;&amp; defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_FELS{$ascf}+G$num_categories{$specify_alpha}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model3c</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Gna"  &amp;&amp; !defined $ascf &amp;&amp; defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_STAM{$ascs}+G$num_categories{$specify_alpha}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
<!-- +ASC_FELS{$ascf} -->
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model4</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Rn" &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable$ascl+R$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model4b</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Rn" &amp;&amp; defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_FELS{$ascf}+R$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model4c</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Rn" &amp;&amp; !defined $ascf &amp;&amp; defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_STAM{$ascs}+R$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
<!-- +ASC_FELS{$ascf} -->
		 								
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model5</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Rnr" &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable$ascl+R$num_categories{$specify_rates}{$specify_weights}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model5b</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Rnr" &amp;&amp; defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_FELS{$ascf}+R$num_categories{$specify_rates}{$specify_weights}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>dna_model5c</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Rnr" &amp;&amp; !defined $ascf &amp;&amp; defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $dna_gtrcat$invariable+ASC_STAM{$ascs}+R$num_categories{$specify_rates}{$specify_weights}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
<!-- ################################################################################################################################ -->					
					<parameter type="Excl">
						<name>dna_gtrcat</name>
						<attributes>
							<prompt>Choose a nucleotide model</prompt>
<!-- -*support 	-f b 	Compute bipartition support for a given reference tree (e.g., best ML tree) using an existing set of replicate trees (e.g., bootstrap trees obtained with -*bootstrap option above). 
		Usage: -*support -*tree bestML.tree -*bs-trees bootstraps.tree  							
								<value>fb</value> -->
<!-- -*bsconverge 	-I 	A posteriori bootstrap convergence test. Usage:	raxml-ng -*bsconverge -*bs-trees bootstraps.tree -*bs-cutoff 0.03								
								<value>I</value> -->								

<!-- -*rfdist 	-f r 	Compute Robinson-Foulds (RF) distance between trees. Usage:-*rfdist -*tree alltrees.nw  
								<value>rfdist</value> </label>	-->

<!-- -*consense 	-J 	Build a consensus tree. Usage:  -*consense MR -*tree alltrees.nw  
								<value>J</value>	 -->
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; $datatype eq "dna" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file</code>
							</precond>
							<vlist>
								<value>JC</value>
								<label>JC</label>
				                <value>K80</value>
								<label>K80</label>
								<value>F81</value>
								<label>F81</label>
				                <value>HKY</value>
								<label>HKY</label>
								<value>TN93ef</value>
								<label>TN93ef</label>
				                <value>TN93</value>
								<label>TN93</label>								
								<value>K81</value>
								<label>K81</label>
				                <value>K81uf</value>
								<label>K81uf</label>								
								<value>TPM2</value>
								<label>TPM2</label>
				                <value>TPM2uf</value>
								<label>TPM2uf</label>								
								<value>TPM3</value>
								<label>TPM3</label>
				                <value>TPM3uf</value>
								<label>TPM3uf</label>
								<value>TIM1</value>
								<label>TIM1</label>
				                <value>TIM1uf</value>
								<label>TIM1uf</label>
								<value>TIM2</value>
								<label>TIM2</label>
				                <value>TIM2uf</value>
								<label>TIM2uf</label>
								<value>TIM3</value>
								<label>TIM3</label>
				                <value>TIM3uf</value>
								<label>TIM3uf</label>								
								<value>TVMef</value>
								<label>TVMef</label>
				                <value>TVM</value>
								<label>TVM</label>								
								<value>SYM</value>
								<label>SYM</label>
				                <value>GTR</value>
								<label>GTR</label>								
							</vlist>
							<vdef>
								<value>GTR</value>
							</vdef>
							<group>20</group>
							<ctrls>
 								<ctrl>
									<message>Please choose a DNA model</message>
									<language>perl</language>
									<code>$datatype eq "dna" &amp;&amp; !defined $dna_gtrcat  </code>
								</ctrl> 
							</ctrls> 
							<comment>
								<value>
								</value>
							</comment>
						</attributes>
					</parameter>
	
<!-- protein model
Protein data*: Blosum62, cpREV, Dayhoff, DCMut, DEN, FLU, HIVb,HIVw, JTT, JTT-DCMut, LG, mtART,mtMAM, mtREV, mtZOA, PMB, rtREV,stmtREV, VT, WAG, LG4M (implies +G4), LG4X (implies +R4), PROTGTR
 -->			            		
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; ($ratehet_model eq "+G" || $ratehet_model eq "+GA" || !defined $ratehet_model) &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable$ascl$ratehet_model$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_modelb</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; ($ratehet_model eq "+G" || $ratehet_model eq "+GA" || !defined $ratehet_model) &amp;&amp; defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_FELS{$ascf}$ratehet_model$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_modelc</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; ($ratehet_model eq "+G" || $ratehet_model eq "+GA" || !defined $ratehet_model) &amp;&amp; !defined $ascf &amp;&amp; defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_STAM{$ascs}$ratehet_model$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
<!-- +ASC_FELS{$ascf} -->					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model2</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Gn"  &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable$ascl+G$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter>
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model2b</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Gn"  &amp;&amp; defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_FELS{$ascf}+G$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter>
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model2c</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Gn"  &amp;&amp; !defined $ascf &amp;&amp; defined $ascs  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_STAM{$ascs}+G$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter>
<!-- +ASC_FELS{$ascf} -->
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model3</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Gna"  &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable$ascl+G$num_categories{$specify_alpha}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model3b</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Gna"  &amp;&amp; defined $ascf &amp;&amp; !defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_FELS{$ascf}+G$num_categories{$specify_alpha}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model3c</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Gna"  &amp;&amp; !defined $ascf &amp;&amp; defined $ascs   </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_STAM{$ascs}+G$num_categories{$specify_alpha}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
<!-- +ASC_FELS{$ascf} -->
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model4</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Rn" &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable$ascl+R$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model4b</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Rn" &amp;&amp; defined $ascf &amp;&amp; !defined $ascs  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_FELS{$ascf}+R$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model4c</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "+Rn" &amp;&amp; !defined $ascf &amp;&amp; defined $ascs  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_STAM{$ascs}+R$num_categories$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
<!-- +ASC_FELS{$ascf} -->
		 								
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model5</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Rnr" &amp;&amp; !defined $ascf &amp;&amp; !defined $ascs  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable$ascl+R$num_categories{$specify_rates}{$specify_weights}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model5b</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Rnr" &amp;&amp; defined $ascf &amp;&amp; !defined $ascs </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_FELS{$ascf}+R$num_categories{$specify_rates}{$specify_weights}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
					<parameter type="String" ishidden="1" issimple="1">
						<name>prot_model5c</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file &amp;&amp; $ratehet_model eq "Rnr" &amp;&amp; !defined $ascf &amp;&amp; defined $ascs  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $prot_matrix_spec$invariable+ASC_STAM{$ascs}+R$num_categories{$specify_rates}{$specify_weights}$empirical"</code>
							</format>
							<group>20</group>
						</attributes>
					</parameter> 
					
<!-- +ASC_FELS{$ascf} -->
					
					<parameter type="Excl" ismandatory="1">
						<name>prot_matrix_spec</name>
						<attributes>
							<prompt>Protein Substitution Matrix</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; $datatype eq "protein" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file  </code>
							</precond>
							<vlist>
								<value>BLOSUM62</value>
								<label>BLOSUM62</label>
								<value>cpREV</value>
								<label>cpREV</label>
								<value>Dayhoff</value>
								<label>Dayhoff</label>
								<value>DCMut</value>
								<label>DCMut</label>
								<value>DEN</value>
								<label>DEN</label>
								<value>FLU</value>
								<label>FLU</label>
								<value>HIVb</value>
								<label>HIVb</label>
								<value>HIVw</value>
								<label>HIVw</label>
								<value>JTT</value>
								<label>JTT</label>
								<value>JTT-DCMut</value>
								<label>JTT-DCMut</label>
								<value>LG</value>
								<label>LG</label>
								<value>LG4X</value>
								<label>LG4X (implies +R4)</label>
								<value>LG4M</value>
								<label>LG4M (implies +G4)</label>
								<value>mtART</value>
								<label>mtART</label>
								<value>mtMAM</value>
								<label>mtMAM</label>
								<value>mtREV</value>
								<label>mtREV</label>
								<value>mtZOA</value>
								<label>mtZOA</label>
								<value>PMB</value>
								<label>PMB</label>
								<value>PROTGTR</value>
								<label>PROTGTR</label>
								<value>rtREV</value>
								<label>rtREV</label>
								<value>stmtREV</value>
								<label>stmtREV</label>
								<value>VT</value>
								<label>VT</label>
								<value>WAG</value>
								<label>WAG</label>
							</vlist>
							<vdef>
								<value>LG</value>
							</vdef>
							<comment>
<value>Please refer to RAxML-NG online manual for the full list of supported models:
https://github.com/amkozlov/raxml-ng/wiki/Input-data#single-model
</value>
							</comment>
						</attributes>
					</parameter>


<!-- Binary data (0/1): BIN, is hidden, no choices -->
					<parameter type="String" ismandatory="1">
						<name>bin_matrix_spec</name>
						<attributes>
							<prompt>Binary Substitution Matrix (automatic, there is only one option)</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; $datatype eq "bin" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model BIN$invariable$ascl$ratehet_model$empirical"</code>
							</format>
							<group>20</group>
							<comment>
<value>For binary data there is only one choice, if this changes you can use the free text model entry option.</value>
							</comment>
						</attributes>
					</parameter>

<!--  Morphological/multistate: MULTIx_MK, MULTIx_GTR (where x = number of states, e.g.: MULTI8_MK for a 8-state model with equal rates) state encoding-->					
					<parameter type="Integer" ismandatory="1">
						<name>state_value</name>
						<attributes>
							<prompt>Number of states for Morphological/Multistate Model</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; $datatype eq "multi" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file  </code>
							</precond>
							<comment>
<value>Morphological/multistate: MULTIx_MK, MULTIx_GTR (where x = number of states, e.g.: MULTI8_MK for a 8-state model with equal rates) state encoding</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter type="Excl" ismandatory="1">
						<name>multimodel_value</name>
						<attributes>
							<prompt>Model for Morphological/Multistate</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; $datatype eq "multi" &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file  </code>
							</precond>
							<vlist>
								<value>_MK</value>
								<label>MK</label>
								<value>_GTR</value>
								<label>GTR</label>
							</vlist>
							<comment>
<value></value>
							</comment>
						</attributes>
					</parameter>	
									
					<parameter type="String" ismandatory="1" ishidden="1">
						<name>multi_matrix_spec</name>
						<attributes>
							<prompt>Morphological/Multistate Model</prompt>
							<precond>
								<language>perl</language>
								<code>$datatype eq "multi"  &amp;&amp; !defined $any_matrix_spec  &amp;&amp; !defined $partition_file  </code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model MULTI$state_value$multimodel_value$invariable$ascl$ratehet_model$empirical"</code>
							</format>
							<group>20</group>
							<comment>
<value></value>
							</comment>
						</attributes>
					</parameter>	
<!-- Unphased diploid genotypes (10 states): GTJC GTHKY4 GTGTR4 GTGTR   -->		

					<parameter type="Excl" ismandatory="1">
						<name>unphased_value</name>
						<attributes>
							<prompt>Model for Unphased diploid genotypes</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; $datatype eq "unphased" &amp;&amp; !defined $any_matrix_spec  &amp;&amp;  !defined $partition_file </code>
							</precond>
							<vlist>
								<value>GTJC</value>
								<label>GTJC</label>
								<value>GTHKY4</value>
								<label>GTHKY4</label>
								<value>GTGTR4</value>
								<label>GTGTR4</label>
								<value>GTGTR</value>
								<label>GTGTR</label>
							</vlist>
							<format>
								<language>perl</language>
								<code>"--model $value$invariable$ascl$ratehet_model$empirical"</code>
							</format>
							<group>20</group>
							<comment>
<value> Unphased diploid genotypes (10 states): GTJC GTHKY4 GTGTR4 GTGTR  </value>
							</comment>
						</attributes>
					</parameter>									
												
				<parameter type="String">
						<name>any_matrix_spec</name>
						<attributes>
							<prompt>Specify your model in free text</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; !defined $partition_file</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--model $value"</code>
							</format>
							<group>20</group>							
							<comment>
<value>You can enter any value here that is not available above. Use this for User-defined symmetries: e.g. DNA010010 (equivalent to HKY) or MULTI5_USERabcdeabcde, or for custom rates files, or for PAML files.</value>
							</comment>
						</attributes>
					</parameter>	
					
<!-- If user doesn't enter a value the partition parameter won't be in the map that the web app sends 
the command renderer (which evaluates the perl for parameters that are present), so we don't need to 
worry about making the format code conditional since this parameter just won't be evaluated. 
Command renderer evaluates 3 types of parameters: 1) those that appear in the map coming from the gui,
 those that are	hidden, 3) those that are of type OutFile or Result. -->
					<parameter type="InFile" >
						<name>partition_file</name>
						<attributes>
							<prompt>Select a partition model file</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>defined $partition_file ? "--model part.txt":""</code>
							</format>
							<ctrls>
								<ctrl>
									<message>Please select a partition model file for the terrace command</message>
									<language>perl</language>
									<code>$select_analysis eq "terrace" &amp;&amp; !defined $partition_file </code>
								</ctrl>
							</ctrls>
							<group>20</group>
							<filenames>part.txt</filenames>
							<comment>
<value>This parameter allows you to specify a file that specifies the regions of your alignment for which an individual model of nucleotide substitution 
should be estimated. This will typically be used to infer trees for long (in terms of base pairs) multi-gene alignments. If DNA and protein mixed models 
are used together (for example) you should choose a model option based on the model of rate heterogeneity you want to use.</value>
<value>for example: GTR+I, p3 = 181-250</value>
<value>Here, each line defines a partition and consist of three elements:</value>
<value>model specification (see above)</value> 
<value>partition name</value>  
<value>range of alignment columns</value>
<value>NOTE: In RAxML, certain model modifiers were global (e.g., GAMMA model of rate heterogeneity), and thus they were specified on the command line and not in partition file. 
In RAxML-NG, this limitation was lifted, i.e. it is now possible to combine partitions with and without GAMMA, proportion of invariant sites etc. (as in example above). However, 
this means that RAxML partition files might need to be adjusted for RAxML-NG (e.g., by adding+G for the partitions where GAMMA model of rate heterogeneity should be used).</value> 
							</comment>
						</attributes>
					</parameter>	
<!-- branch length estimation for partitoned data -->
<!-- In case of partitioned analysis, three branch length estimation modes are available:
Command 	Meaning
-*brlen linked 	Branch lengths are identical for all partitions
-*brlen scaled 	(default) Joint branch length estimation with individual per-partition scalers (i.e., branch lengths are proportional)
-*brlen unlinked 	Branch lengths are estimated independently for each partition (cf. RAxML -M option) -->

<parameter type="Excl">
						<name>select_brlength</name>
						<attributes>
							<prompt>Select branch length estimation method (--brlen)</prompt>	
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
							</precond>						
							<vlist>
								<value>linked</value>
								<label>linked</label>
								<value>scaled</value>
								<label>scaled</label>								
								<value>unlinked</value>
								<label>unlinked</label>
							</vlist>
							<format>
								<language>perl</language>
								<code> ($value ne $vdef)?" -brlen $value":""</code>
							</format>
							<vdef>
								<value>scaled</value>
							</vdef>
							<group>20</group>
							<comment>
								<value>In case of partitioned analysis, three branch length estimation modes are available: linked - Branch lengths are identical for all partitions
scaled (default) - Joint branch length estimation with individual per-partition scalers (i.e., branch lengths are proportional); unlinked - Branch lengths are estimated independently for each partition (cf. RAxML -M option)
								</value>
							</comment>
						</attributes>
					</parameter>

					
<!-- custom rates file  -->	
					<parameter type="InFile" >
						<name>rates_file</name>
						<attributes>
							<prompt>Select a custom rates file</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; !defined $partition_file</code>
							</precond>
							<group>20</group>
							<filenames>rates.txt</filenames>
							<comment>
<value>If you select a file here, use the free text box to specify your model, and use the format: model{rates.txt}, for example PROTGTR{rates.txt}</value>
							</comment>
						</attributes>
					</parameter>	
					
<!-- custom rates file  -->	
					<parameter type="InFile" >
						<name>PAML_file</name>
						<attributes>
							<prompt>Select a PAML file</prompt>
							<group>20</group>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; !defined $partition_file</code>
							</precond>
							<filenames>PAML.txt</filenames>
							<comment>
<value>If you specify a file here, use the free text box to specify your PAML file, and use the format: model{PAML.txt}, for example PROTGTR{PAML.txt}</value>
							</comment>
						</attributes>
					</parameter>	
<!-- charmap.txt -->
					<parameter type="InFile" >
						<name>character_file</name>
						<attributes>
							<prompt>Specify a custom character map file</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; !defined $partition_file</code>
							</precond>
							<group>20</group>
							<filenames>charmap.txt</filenames>
							<comment>
<value>If you specify a file here, use the free text box to specify +M{charmap.txt}</value>
							</comment>
						</attributes>
					</parameter>						
		</parameters>
	</paragraph>
</parameter>

<!-- among site rate hetogeneity -->

<parameter type="Paragraph">
	<paragraph>
		<name>amongsite_ratehet</name>
		<prompt>Among Site Rate Heterogeneity Options</prompt>
		<parameters>

<!--
Among-site rate heterogeneity model
+G (discrete GAMMA with 4 categories, mean category rates, ML estimate of alpha)
+GA (as above, but with median category rates)
+Gn (discrete GAMMA with n categories, ML estimate of alpha)
+Gn{a} (discrete GAMMA with n categories and user-defined alpha a)
+Rn (FreeRate with n categories, ML estimate of rates and weights)
+Rn{r1/r2/../rn}{w1/w2/../wn} (FreeRate with n categories, user-defined rates r1 r2 ... rn and weights w1 w2 ... wn) -->

	<parameter type="Excl">
			<name>ratehet_model</name>
			<attributes>
				<prompt>Among-site rate heterogeneity model</prompt>
				<precond>
					<language>perl</language>
					<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
				</precond>
				<vlist>
					<value>+G</value>
					<label>discrete GAMMA with 4 categories, mean category rates, ML estimate of alpha (+G)</label>
					<value>+GA</value>
					<label>discrete GAMMA with 4 categories, median category rates, ML estimate of alpha (+GA)</label>
					<value>+Gn</value>
					<label>discrete GAMMA with n categories, ML estimate of alpha (+Gn)</label>
					<value>Gna</value>
					<label>discrete GAMMA with n categories and user-defined alpha a (+Gna)</label>
					<value>+Rn</value>
					<label>FreeRate with n categories, ML estimate of rates and weights (+Rn)</label>
					<value>Rnr</value>
					<label>FreeRate with n categories, user-defined rates r1 r2 ... rn and weights w1 w2 ... wn)(rnr)</label>
				</vlist>
				<vdef>
					<value>+G</value>
				</vdef>				
				<ctrls>
					<ctrl>
						<message>Please Enter a value for the number of categories</message>
						<language>perl</language>
						<code>($ratehet_model eq "+Gn" || $ratehet_model eq "Gna" || $ratehet_model eq "+Rn"|| $ratehet_model eq "Rnr" ) &amp;&amp; !defined $num_categories</code>
					</ctrl>
					<ctrl>
						<message>Please enter a value for alpha</message>
						<language>perl</language>
						<code>$ratehet_model eq "Gna" &amp;&amp; !defined $specify_alpha</code>
					</ctrl>
					<ctrl>
						<message>Please enter a value for weights</message>
						<language>perl</language>
						<code>$ratehet_model eq "Rnr" &amp;&amp; !defined $specify_weights</code>
					</ctrl>
					<ctrl>
						<message>Please enter a value for rates</message>
						<language>perl</language>
						<code>$ratehet_model eq "Rnr" &amp;&amp; !defined $specify_rates</code>
					</ctrl>
				</ctrls>				
			</attributes>
		</parameter>
		
		<parameter type="Integer">
			<name>num_categories</name>
			<attributes>
				<prompt>Specify the number of categories</prompt>
				<precond>
					<language>perl</language>
					<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; ($ratehet_model eq "+Gn" || $ratehet_model eq "Gna" || $ratehet_model eq "+Rn" || $ratehet_model eq "Rnr" ) </code>
				</precond>
			</attributes>
		</parameter>
		
		<parameter type="Float">
			<name>specify_alpha</name>
			<attributes>
				<prompt>Specify alpha</prompt>
				<precond>
					<language>perl</language>
					<code>$ratehet_model eq "Gna" </code>
				</precond>
			</attributes>
		</parameter>

		<parameter type="Float">
			<name>specify_rates</name>
			<attributes>
				<prompt>Specify the rates</prompt>
				<precond>
					<language>perl</language>
					<code>$ratehet_model eq "Rnr" </code>
				</precond>
			</attributes>
		</parameter>
		
		<parameter type="Float">
			<name>specify_weights</name>
			<attributes>
				<prompt>Specify the weights</prompt>
				<precond>
					<language>perl</language>
					<code>$ratehet_model eq "Rnr"</code>
				</precond>
			</attributes>
		</parameter>
		
		</parameters>
	</paragraph>
</parameter>

<parameter type="Paragraph">
	<paragraph>
		<name>matrix_modifiers</name>
		<prompt>Model Options</prompt>
		<parameters>
<!-- Estimate proportion of invariable sites, mlsearch is a precondition  -->
<!-- The control should be of type switch, but I need the value of the parameter to be either "I" or "", so I made it type Excl instead. -->
<!-- +I or +IO (ML estimate) +IC (empirical) +IU{p} (user-defined: p) -->
		
		<parameter type="Excl">
			<name>invariable</name>
			<attributes>
				<prompt>Estimate proportion of invariable sites ( + I)</prompt>
				<precond>
					<language>perl</language>
					<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
				</precond>
				<vlist>
					<value>+IO</value>
					<label>ML Estimate</label>
					<value>+IC</value>
					<label>Empirical</label>
				</vlist>
			</attributes>
		</parameter>
		
		<parameter type="String">
			<name>userdefined_invariable</name>
			<attributes>
				<prompt>Enter the user-defined proportion of invariable sites: enter {p}</prompt>
				<precond>
					<language>perl</language>
					<code>!defined $invariable &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
				</precond>
				<format>
					<language>perl</language>
					<code>defined $value ? "+IU{$userdefined_invariable}":""</code>
				</format>
				<group>20</group>				
				<comment>
				<value>This parameter adds the string +IU{p} to the command line, where p is the user defined invariable parameter. Enter the just the value of p here, and the application will place it inside the curly braces for you, eg, if you enter x the command line will print as +IU{x}.</value>
				</comment>
			</attributes>
		</parameter>

			</parameters>
	</paragraph>
</parameter>	
		
<!-- Empirical Base Frequencies -->
<!-- +F or 
+FC (empirical)
+FO 0(ML estimate)
+FE (equal)
+FU{f1/f2/../fn} (user-defined: f1 f2 ... fn)
+FU{freqs.txt} (user-defined from file) -->		
		<parameter type="Excl">
			<name>empirical</name>
			<attributes>
				<prompt>Base frequencies</prompt>
				<precond>
					<language>perl</language>
					<code>$select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
				</precond>
				<vlist>
					<value></value>
					<label>No</label>
					<value>+FC</value>
					<label>empirical (+FC)</label>
					<value>+FO</value>
					<label>ML estimate (+FO)</label>
					<value>+FE</value>
					<label>equal (+FE)</label>
					<value>+FU{freqs.txt}</value>
					<label>From file (+FU)</label>
				</vlist>
				<vdef>
					<value></value>
				</vdef>
			</attributes>
		</parameter>
		
<!-- upload the user specified freqs file -->
		<parameter type="InFile">
			<name>empirical_file</name>
			<attributes>
				<prompt>Select empirical base frequencies file</prompt>
				<precond>
					<language>perl</language>
					<code>$empirical eq "+FU{freqs.txt}"</code>
				</precond>
				<filenames>freqs.txt</filenames>
				<ctrls>
					<ctrl>
						<message>Please select a file with empirical base frequencies</message>
						<language>perl</language>
						<code>$empirical eq "+FU{freqs.txt}" &amp;&amp; !defined $empirical_file</code>
					</ctrl>
				</ctrls>
				<comment>
<value></value>
				</comment>
			</attributes>
		</parameter>
		


<parameter type="Paragraph">
	<paragraph>
		<name>ascertainment_config</name>
		<prompt>Ascertainment Bias Confguration</prompt>
		<parameters>
<!-- +ASC_LEWIS (Lewis' method)
+ASC_FELS{w} (Felsenstein's method with total number of invariable sites w)
+ASC_STAM{w1/w2/../wn} (Stamatakis' method with per-state invariable site numbers w1 w2 ... wn) -->
					<parameter issimple="0" type="Excl" >
						<name>ascl</name>
						<attributes>
							<prompt>Lewis Correction for Ascertainment bias (ASC_)</prompt>
							<precond>
								<language>perl</language>
								<code>!defined $invariable &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
							</precond>
							<vlist>
								<value>+ASC_LEWIS</value>
								<label>YES</label>
								<value></value>
								<label>No</label>
							</vlist>
							<warns>
								<warn>
									<message>Ascertainment bias correction will be applied only to partitions for which it is requested in the partition file (-q)</message>
									<language>perl</language>
									<code>$ascertainment eq "ASC_" &amp;&amp; defined $partition</code>
								</warn>
							</warns>
							<ctrls>
								<ctrl>
									<message>Sorry, you can not use two types of Ascertainment bias correction</message>
									<language>perl</language>
									<code>$ascl &amp;&amp; (defined $ascf || defined $ascs)</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>This is useful for binary/morphological datasets  that only contain variable sites (the identical morphological features are usually not
included in the alignments, hence you need to correct for this, see, e.g., http://sysbio.oxfordjournals.org/content/50/6/913.short).For DNA data this option might be useful when
you analyze alignments of SNPs that also don't contain constant sites. Note that, for mathematical and numerical reasons you can
not apply an ascertainment bias correction to datasets or partitions that contain constantsites. In this case, RAxML will exit with an error.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter issimple="0" type="String" >
						<name>ascf</name>
						<attributes>
							<prompt>Enter Felsenstein Correction for Ascertainment bias (ASC_)</prompt>
							<precond>
								<language>perl</language>
								<code>!defined $invariable &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
							</precond>
							<warns>
								<warn>
									<message>Ascertainment bias correction will be applied only to partitions for which it is requested in the partition file (-q)</message>
									<language>perl</language>
									<code>$ascertainment eq "ASC_" &amp;&amp; defined $partition</code>
								</warn>
							</warns>
							<ctrls>
								<ctrl>
									<message>Sorry, you can not use two types of Ascertainment bias correction</message>
									<language>perl</language>
									<code>defined $ascf &amp;&amp; defined $ascs</code>
								</ctrl>
							</ctrls>
							<comment>
								<value>This is useful for binary/morphological datasets  that only contain variable sites (the identical morphological features are usually not
included in the alignments, hence you need to correct for this, see, e.g., http://sysbio.oxfordjournals.org/content/50/6/913.short).For DNA data this option might be useful when
you analyze alignments of SNPs that also don't contain constant sites. Note that, for mathematical and numerical reasons you can
not apply an ascertainment bias correction to datasets or partitions that contain constantsites. In this case, RAxML will exit with an error.</value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter issimple="0" type="String" >
						<name>ascs</name>
						<attributes>
							<prompt>Enter Stamatakis Correction for Ascertainment bias (ASC_)</prompt>
							<precond>
								<language>perl</language>
								<code>!defined $invariable &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
							</precond>
							<warns>
								<warn>
									<message>Ascertainment bias correction will be applied only to partitions for which it is requested in the partition file (-q)</message>
									<language>perl</language>
									<code>$ascertainment eq "ASC_" &amp;&amp; defined $partition</code>
								</warn>
							</warns>
							<comment>
								<value>This is useful for binary/morphological datasets  that only contain variable sites (the identical morphological features are usually not
included in the alignments, hence you need to correct for this, see, e.g., http://sysbio.oxfordjournals.org/content/50/6/913.short).For DNA data this option might be useful when
you analyze alignments of SNPs that also don't contain constant sites. Note that, for mathematical and numerical reasons you can
not apply an ascertainment bias correction to datasets or partitions that contain constantsites. In this case, RAxML will exit with an error.</value>
							</comment>
						</attributes>
					</parameter>							
							
<!-- end ascertainment bias		-->

		</parameters>
	</paragraph>
</parameter>
					
<!--  Starting tree(s) -->
				
		<!-- user supplied starting tree (-tree) -->
		<!-- 
Starting tree(s)

Default number of starting trees depends on RAxML-NG version and command:
Command 	v0.8.0 and later 	
-*search 	10 random + 10 parsimony 
-*search1 	1 random 	N/A
-*all 	10 random + 10 parsimony 	-->

<parameter type="Paragraph">
	<paragraph>
		<name>tree_opts</name>
		<prompt>Tree Options</prompt>

		<parameters>
					<parameter type="InFile">
						<name>besttree_upload</name>
						<attributes>
							<prompt>Select a tree for terrace, or ancestral analysis</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "fA" || $select_analysis eq "terrace"</code>
							</precond>
							<filenames>best.tre</filenames>
							<ctrls>
								<ctrl>
									<message>Please select a tree for your terrace or ancestral analysis</message>
									<language>perl</language>
									<code>($select_analysis eq "fA" || $select_analysis eq "terrace") &amp;&amp; !defined $besttree_upload </code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter>
					
<!-- 				<parameter type="InFile">
						<name>alltrees_upload</name>
						<attributes>
							<prompt>Select a set of trees for RF or a consense analysis</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "rfdist"</code>
							</precond>
							<filenames>alltrees.nw</filenames>
							<ctrls>
								<ctrl>
									<message>Please select a set of trees for RF or a consense analysis</message>
									<language>perl</language>
									<code>($select_analysis eq "J" || $select_analysis eq "rfdist") &amp;&amp; !defined $alltrees_upload </code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter>   --> 
					
<!--  bestML.tree provide a reference tree for calculating support -->
					<parameter type="InFile">
						<name>referencetree_upload</name>
						<attributes>
							<prompt>Provide a tree to evaluate, to compute log-likelihood or to compute site likelihood</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "evaluate" || $select_analysis eq "sitelh" || $select_analysis eq "loglh"</code>
							</precond>
							<filenames>best.tre</filenames>
							<ctrls>
								<ctrl>
									<message>Provide a tree to evaluate, for per-site log-likelihood, or for log likelihood </message>
									<language>perl</language>
									<code>($select_analysis eq "evaluate" || $select_analysis eq "sitelh" || $select_analysis eq "loglh") &amp;&amp; !defined $referencetree_upload </code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter> 

<!-- bootstraps.tre  -->
					<parameter type="InFile">
						<name>bootstrapstree_upload</name>
						<attributes>
							<prompt>Select a set of bootstrap trees for support option or a posteriori analysis</prompt>
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "fb"</code>
							</precond>
							<filenames>bootstraps.tre</filenames>
							<ctrls>
								<ctrl>
									<message>Please select a set of bootstrap trees</message>
									<language>perl</language>
									<code>($select_analysis eq "fb") &amp;&amp; !defined $bootstrapstree_upload </code>
								</ctrl>
							</ctrls>
						</attributes>
					</parameter> 	
											
<!-- Option: -*tree rand{N} | pars{N} | FILE -->							
					<parameter type="Integer">
						<name>starting_parstree</name>
						<attributes>
							<prompt>Number of parsimony starting trees</prompt>
								<precond>
									<language>perl</language>
									<code>!$startingtree_method &amp;&amp; !defined $constraint &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; $select_analysis ne "fe" &amp;&amp; $select_analysis ne "loglh"</code>
								</precond>
							<format>
								<language>perl</language>
								<code>defined $value ? "--tree pars{$starting_parstree}":""</code>
							</format>
							<group>20</group>
							<comment>
<value>RAxML-NG supports three types of starting trees. pars(imony): start from a tree generated by the parsimony-based randomized stepwise addition algorithm
user-defined: load a custom starting tree from the NEWICK file. For random and parsimony, you can specify the number of trees to generate
in curly brackets (e.g., pars{10} or rand{20}). In this case, RAxML-NG will perform multiple tree searches (one per each starting tree), and pick the 
best-scoring topology as the final ML tree. You can also combine both parsimony and random starting trees in one run, e.g. -*tree pars{10},rand{10}.
</value>
							</comment>
						</attributes>
					</parameter>
					
<!-- Option: -*tree rand{N} | pars{N} | FILE -->							
					<parameter type="Integer">
						<name>starting_randtree</name>
						<attributes>
							<prompt>Number of random starting trees</prompt>
							<precond>
									<language>perl</language>
									<code>!$startingtree_method &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J"</code>
								</precond>
							<format>
								<language>perl</language>
								<code>defined $value ? "--tree rand{$starting_randtree}":""</code>
							</format>
							<group>20</group>
							<comment>
<value>rand(om): start trees from a random topology.</value>
							</comment>
						</attributes>
					</parameter>		
					
					<parameter type="InFile">
						<name>startingtree_upload</name>
						<attributes>
							<prompt>Select a custom starting tree</prompt>
								<precond>
									<language>perl</language>
									<code>!defined $constraint &amp;&amp; $select_analysis ne "fb" &amp;&amp; $select_analysis ne "I" &amp;&amp; $select_analysis ne "rfdist"  &amp;&amp;  $select_analysis ne "J" &amp;&amp; $select_analysis ne "evaluate"  &amp;&amp; $select_analysis ne "loglh"</code>
								</precond>					
							<format>
								<language>perl</language>
								<code>defined $value ? " --tree startingtree.tre":""</code>
							</format>
							<group>20</group>
							<filenames>startingtree.tre</filenames>
							<comment>
<value>Specify a user starting tree file in Newick format. Note that Newick file can also contain multiple starting trees, in which case RAxML-NG will conduct multiple tree searches (one per starting tree).</value>
							</comment>
						</attributes>
					</parameter>
									
		</parameters>
	</paragraph>
</parameter>

 
 <parameter type="Paragraph">
	<paragraph>
		<name>consensus_opts</name>
		<prompt>Consensus Tree Options</prompt>
<!-- 
Consensus Tree Options

Fields 9 and 10 are disabled unless Analysis type == -*consense. 
Field 10 is disabled unless Field 9 == MR.
Fields 9 and 10 are translated into optional argument of -*consense option, e.g.:
STRICT -*consense STRICT
MR, Field 10 is empty (default)  -*consense
MR, Field 10 = 75  -*consense MR75
MRE  -*consense MRE
 -->
		<parameters>
		
		<!-- O9. Consensus type: [ ] STRICT   [x] MR (majority rule)   [ ] MRE (extended majority) -->							
					<parameter ismandatory="1" type="Excl">
						<name>specify_consense</name>
						<attributes>
							<prompt>Consensus type</prompt>
							<precond>
									<language>perl</language>
									<code>$select_analysis eq "J"</code>
							</precond>
							<vlist>
								<value>STRICT</value>
								<label>Strict</label>
								<value>MR</value>
								<label>Majority Rule</label>
								<value>MRE</value>
								<label>Extended Majority Rule</label>
							</vlist>
							<vdef>
								<value>MR</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Please select a consensus type</message>
									<language>perl</language>
									<code>$select_analysis eq "J" &amp;&amp; !defined $specify_consense</code>
								</ctrl>
							</ctrls>						
							<group>20</group>
							<comment>
<value></value>
							</comment>
						</attributes>
					</parameter>
					
<!-- MR consensus threshold x (50 <= x <= 100, default: 50) -->							
					<parameter type="Integer">
						<name>specify_consensethresh</name>
						<attributes>
							<prompt>MR consensus threshold x (default: 50)</prompt>
							<precond>
									<language>perl</language>
									<code>$select_analysis eq "J" &amp;&amp; $specify_consense eq "MR"</code>
							</precond>
							<vdef>
								<value>50</value>
							</vdef>
							<ctrls>
								<ctrl>
									<message>Consensus threshhold must be between 50 and 100. Default=50</message>
									<language>perl</language>
									<code>$specify_consensethresh &lt; 50 </code>
								</ctrl>
							</ctrls>
							<group>20</group>
							<comment>
<value></value>
							</comment>
						</attributes>
					</parameter>
					
					<parameter ishidden="1" type="String">
						<name>specify_consensethresh2</name>
						<attributes>
							<precond>
								<language>perl</language>
								<code>$select_analysis eq "J" &amp;&amp; $specify_consense eq "MR"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--consense MR$specify_consensethresh --tree infile.txt"</code>
							</format>
							<group>20</group>
							<comment>
<value></value>
							</comment>
						</attributes>
					</parameter>
<!-- MR consensus threshold x (50 <= x <= 100, default: 50):   -->					
					<parameter ishidden="1" type="String">
						<name>specify_consensethresh3</name>
						<attributes>
							<precond>
									<language>perl</language>
									<code>$select_analysis eq "J" &amp;&amp; $specify_consense ne "MR"</code>
							</precond>
							<format>
								<language>perl</language>
								<code>"--consense $specify_consense --tree infile.txt"</code>
							</format>
							<group>20</group>
							<comment>
<value></value>
							</comment>
						</attributes>
					</parameter>		

		</parameters>
	</paragraph>
</parameter>

<!-- log verbosity
Log level 	Description
-*log ERROR 	Silent (only error messages)
-*log WARNING 	+ Print warnings
-*log RESULT 	+ Print results, e.g. final tree log-likelihood
-*log INFO 	+ Print additional info, e.g. alignment dimensions (default)
-*log PROGRESS 	+ Print search progress messages
-*log VERBOSE 	+ Print even more details. e.g. evolutionary model parameters
-*log DEBUG 	+ Print diagnostic messages -->													
	<parameter type="Excl" >
						<name>setlogVerbosity</name>
						<attributes>
							<prompt>Set the log verbosity (--log xxx)</prompt>
							<vlist>
								<value>ERROR</value>
								<label>Silent (only error messages)</label>
								<value>WARNING</value>
								<label>Print warnings</label>								
								<value>RESULT</value>
								<label>Print results</label>
								<value>INFO</value>
								<label>Print additional info</label>
								<value>PROGRESS</value>
								<label>Print search progress</label>															
								<value>VERBOSE</value>
								<label>Print most details</label>								
								<value>DEBUG</value>
								<label>Print diagnostic messages</label>
							</vlist>
							<format>
								<language>perl</language>
								<code>defined ($value)?" --log $value":""</code>
							</format>
							<group>20</group>							
						</attributes>
					</parameter>
	
		
	 	<parameter type="Results">
				<name>all_outputfiles</name>
				<attributes>
					<filenames>*</filenames>
				</attributes>
			</parameter>	
			

<!-- return raxml result files  -->	
		
	 	<parameter type="Results">
				<name>raxml_outputfiles</name>
				<attributes>
					<filenames>RAXML_*</filenames>
				</attributes>
			</parameter>	
							


	</parameters>
</pise>
