<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE pise PUBLIC "pise2.dtd" "pise2.dtd" >
<pise>
	<head>
		<title>IQ-Tree on ACCESS</title>
		<version>2.4.0</version>
		<description>Efficient phylogenomic software by maximum likelihood, run on XSEDE</description>
		<authors>L.-T. Nguyen, H.A. Schmidt, A. von Haeseler, and B.Q. Minh</authors>
		<reference>B.Q. Minh, H.A. Schmidt, O. Chernomor, D. Schrempf, M.D. Woodhams, A. von Haeseler, R. Lanfear (2020) IQ-TREE 2: New models and efficient methods for phylogenetic inference in the genomic era. Mol. Biol. Evol., 37:1530-1534. https://doi.org/10.1093/molbev/msaa015</reference>
		<category>Phylogeny / Alignment</category>
	</head>
	
	<command>iqtree_xsede_expanse</command>
<!--
*****************************************************************************************************************************************
Created by Mark Miller for CSG, 5/2/2017
***************************************************************************************************************************************** -->
<!-- modified for expanse -->
<!-- v 2.0+ commands  -->
<!--  -ntmax Specify the maximal number of CPU cores -nt AUTO is allowed to
allocate DEFAULT: #CPU cores on the current machine (v 2.0+)  -->

<!-- Usage: /projects/ps-ngbt/opt/comet/iqtree-omp-1.5.4-Linux/bin/iqtree-omp -s <alignment> [OPTIONS]

GENERAL OPTIONS:
  -? or -h             Print this help dialog
  -s <alignment>       Input alignment in PHYLIP/FASTA/NEXUS/CLUSTAL/MSF format
  -st <data_type>      BIN, DNA, AA, NT2AA, CODON, MORPH (default: auto-detect)
  -t <start_tree_file> or -t BIONJ or -t RANDOM
                       Starting tree (default: 99 parsimony tree and BIONJ)
  -te <user_tree_file> Like -t but fixing user tree (no tree search performed)
  -o <outgroup_taxon>  Outgroup taxon name for writing .treefile
  -pre <PREFIX>        Prefix for all output files (default: aln/partition)
  -nt <#cpu_cores>     Number of cores/threads to use (REQUIRED)
  -seed <number>       Random seed number, normally used for debugging purpose
  -v, -vv, -vvv        Verbose mode, printing more messages to screen
  -quiet               Quiet mode, suppress printing to screen (stdout)
 -keep-ident          Keep identical sequences (default: remove & finally add)
  -safe                Safe likelihood kernel to avoid numerical underflow
  -mem RAM             Maximal RAM usage for memory saving mode 
         
  -q <partition_file>  Edge-linked partition model (file in NEXUS/RAxML format)
 -spp <partition_file> Like -q option but allowing partition-specific rates
  -sp <partition_file> Edge-unlinked partition model (like -M option of RAxML)

CHECKPOINTING TO RESUME STOPPED RUN:
  -redo                Redo analysis even for successful runs (default: resume)
  -cptime <seconds>    Minimum checkpoint time interval (default: 20)

LIKELIHOOD MAPPING ANALYSIS:
  -lmap <#quartets>    Number of quartets for likelihood mapping analysis
  -lmclust <clustfile> NEXUS file containing clusters for likelihood mapping
  -wql                 Print quartet log-likelihoods to .quartetlh file
  -n 0 Skip subsequent tree search, useful when you only want to assess the
       phylogenetic information of the alignment. Version 2.0+
       
MODEL-FINDER:
  -m TESTONLY          Perform standard model selection like jModelTest (for DNA)
					   and ProtTest (for protein). Moreover, IQ-TREE also works
					   for codon, binary and morphogical data. If a partition file is
					   specified, IQ-TREE will find the best-fit model for each
					   partition.
  -m TEST              Like -m TESTONLY but immediately followed by tree
                       reconstruction using the best-fit model found. So this
					   performs both model selection and tree inference within a
					   single run.
  -m MF                Perform an extended model selection that additionally
					   includes FreeRate model compared with -m TESTONLY.
					   Recommended as replacement for -m TESTONLY. Note that
					   LG4X is a FreeRate model, but by default is not included
					   because it is also a protein mixture model. To include it, use
					   -madd option (see table below).
  -m MFP               Like -m MF but immediately followed by tree reconstruction
					   using the best-fit model found. Identical to TESTNEW

####when a partition file is included via -q, use the MERGE Option####

  -m TESTMERGEONLY     Select best-fit partitioning scheme by possibly merging partitions
  					   to reduce over-parameterization and increase modelfit. It implements
  					   the greedy algorithm of PartitionFinder
  -m TESTMERGE         TESTMERGE, then Find best partition scheme followed by tree inference
  -m TESTNEWMERGEONLY  Like -m TESTMERGEONLY but additionally includes FreeRate
model.
  -m MF+MERGE          Find best partition scheme incl. FreeRate heterogeneity
  -m MFP+MERGE         Like -m MF+MERGE followed by tree inference
  -rcluster <percent>  Percentage of partition pairs (relaxed clustering alg.)
  -mset program        Restrict search to models supported by other programs
                       (raxml, phyml or mrbayes)
  -mset m1,...,mk      Restrict search to models in a comma-separated list
                       (e.g. -mset WAG,LG,JTT)
  -msub source         Restrict search to AA models for specific sources
                       (nuclear, mitochondrial, chloroplast or viral)
  -mfreq f1,...,fk     Restrict search to using a list of state frequencies
                       (default AA: -mfreq FU,F; codon: -mfreq ,F1x4,F3x4,F)
  -mrate r1,...,rk     Restrict search to a list of rate-across-sites models
                       (e.g. -mrate E,I,G,I+G,R is used for -m MF)
  -cmin <kmin>         Min #categories for FreeRate model [+R] (default: 2)
  -cmax <kmax>         Max #categories for FreeRate model [+R] (default: 10)
  -merit AIC|AICc|BIC  Optimality criterion to use (default: all)
  -mtree               Perform full tree search for each model considered
  -mredo               Ignore model results computed earlier (default: reuse)
  -madd mx1,...,mxk    List of mixture models to also consider
  -mdef <nexus_file>   A model definition NEXUS file (see Manual)

NEW STOCHASTIC TREE SEARCH ALGORITHM:
  -ninit <number>      Number of initial parsimony trees (default: 100)
  -ntop <number>       Number of top initial trees (default: 20)
  -nbest <number>      Number of best trees retained during search (defaut: 5)
  -n <#iterations>     Fix number of iterations to stop (default: auto)
  -nstop <number>      Number of unsuccessful iterations to stop (default: 100)
  -pers <proportion>   Perturbation strength for randomized NNI (default: 0.5)
  -sprrad <number>     Radius for parsimony SPR search (default: 6)
  -allnni              Perform more thorough NNI search (default: off)
  -g <constraint_tree> (Multifurcating) topological constraint tree file

ULTRAFAST BOOTSTRAP:
  -bb <#replicates>    Ultrafast bootstrap (>=1000)
  -bnni Starting with IQ-TREE version 1.6 we provide a new option -bnni to reduce the risk
of overestimating branch supports with UFBoot due to severe model violations. With
this option UFBoot will further optimize each bootstrap tree using a hill-climbing nearest
neighbor interchange (NNI) search based directly on the corresponding bootstrap alignment.
  -wbt                 Write bootstrap trees to .ufboot file (default: none)
  -wbtl                Like -wbt but also writing branch lengths
  -nm <#iterations>    Maximum number of iterations (default: 1000)
  -nstep <#iterations> #Iterations for UFBoot stopping rule (default: 100)
  -bcor <min_corr>     Minimum correlation coefficient (default: 0.99)
  -beps <epsilon>      RELL epsilon to break tie (default: 0.5)

STANDARD NON-PARAMETRIC BOOTSTRAP:
  -b <#replicates>     Bootstrap + ML tree + consensus tree (>=100)
  -bc <#replicates>    Bootstrap + consensus tree
  -bo <#replicates>    Bootstrap only

SINGLE BRANCH TEST:
  -alrt <#replicates>  SH-like approximate likelihood ratio test (SH-aLRT)
  -alrt 0              Parametric aLRT test (Anisimova and Gascuel 2006)
  -abayes              approximate Bayes test (Anisimova et al. 2011)
  -lbp <#replicates>   Fast local bootstrap probabilities

SUBSTITUTION MODEL:
  -m <model_name>
                  DNA: HKY (default), JC, F81, K2P, K3P, K81uf, TN/TrN, TNef,
                       TIM, TIMef, TVM, TVMef, SYM, GTR, or 6-digit model
                       specification (e.g., 010010 = HKY)
              Protein: LG (default), Poisson, cpREV, mtREV, Dayhoff, mtMAM,
                       JTT, WAG, mtART, mtZOA, VT, rtREV, DCMut, PMB, HIVb,
                       HIVw, JTTDCMut, FLU, Blosum62, GTR20
      Protein mixture: C10,...,C60, EX2, EX3, EHO, UL2, UL3, EX_EHO, LG4M, LG4X
               Binary: JC2 (default), GTR2
      Empirical codon: KOSI07, SCHN05
    Mechanistic codon: GY (default), MG, MGK, GY0K, GY1KTS, GY1KTV, GY2K,
                       MG1KTS, MG1KTV, MG2K
 Semi-empirical codon: XX_YY where XX is empirical and YY is mechanistic model
       Morphology/SNP: MK (default), ORDERED
            Otherwise: Name of file containing user-model parameters
                       (rate parameters and state frequencies)
  -m <model_name>+F or +FO or +FU or +FQ (default: auto)
                       counted, optimized, user-defined, equal state frequency
  -m <model_name>+F1x4 or +F3x4
                       Codon frequencies
  -m <model_name>+ASC  Ascertainment bias correction for morphological/SNP data
  -m "MIX{m1,...mK}"   Mixture model with K components
  -m "FMIX{f1,...fK}"  Frequency mixture model with K components
  -mwopt               Turn on optimizing mixture weights (default: auto)

RATE HETEROGENEITY AMONG SITES:
  -m <model_name>+I or +G[n] or +I+G[n] or +R[n]
                       Invar, Gamma, Invar+Gamma, or FreeRate model where n is
                       number of categories (default: n=4)
  -a <Gamma_shape>     Gamma shape parameter for site rates (default: estimate)
  -amin <min_shape>    Min Gamma shape parameter for site rates (default: 0.02)
  -gmedian             Median approximation for +G site rates (default: mean)
  -*opt-gamma-inv      More thorough estimation for +I+G model parameters
  -i <p_invar>         Proportion of invariable sites (default: estimate)
  -wsr                 Write site rates to .rate file
  -mh                  Computing site-specific rates to .mhrate file using
                       Meyer & von Haeseler (2003) method

SITE-SPECIFIC FREQUENCY MODEL:
  -ft <tree_file>      Input tree to infer site frequency model
  -fs <in_freq_file>   Input site frequency model file
  -fmax                Posterior maximum instead of mean approximation

CONSENSUS RECONSTRUCTION:
  -t <tree_file>       Set of input trees for consensus reconstruction
  -minsup <threshold>  Min split support in range [0,1]; 0.5 for majority-rule
                       consensus (default: 0, i.e. extended consensus)
  -bi <burnin>         Discarding <burnin> trees at beginning of <treefile>
  -con                 Computing consensus tree to .contree file
  -net                 Computing consensus network to .nex file
  -sup <target_tree>   Assigning support values for <target_tree> to .suptree
  -suptag <name>       Node name (or ALL) to assign tree IDs where node occurs

ROBINSON-FOULDS DISTANCE:
  -rf_all              Computing all-to-all RF distances of trees in <treefile>
  -rf <treefile2>      Computing all RF distances between two sets of trees
                       stored in <treefile> and <treefile2>
  -rf_adj              Computing RF distances of adjacent trees in <treefile>

TREE TOPOLOGY TEST:
  -z <trees_file>      Evaluating a set of user trees
  -zb <#replicates>    Performing BP,KH,SH,ELW tests for trees passed via -z
  -zw                  Also performing weighted-KH and weighted-SH tests
  -au                  Also performing approximately unbiased (AU) test

GENERATING RANDOM TREES:
  -r <num_taxa>        Create a random tree under Yule-Harding model
  -ru <num_taxa>       Create a random tree under Uniform model
  -rcat <num_taxa>     Create a random caterpillar tree
  -rbal <num_taxa>     Create a random balanced tree
  -rcsg <num_taxa>     Create a random circular split network
  -rlen <min_len> <mean_len> <max_len>  
                       min, mean, and max branch lengths of random trees

MISCELLANEOUS:
  -wt                  Write locally optimal trees into .treels file
  -blfix               Fix branch lengths of user tree passed via -te
  -blscale             Scale branch lengths of user tree passed via -t
  -blmin               Min branch length for optimization (default 0.000001)
  -blmax               Max branch length for optimization (default 100)
  -wsr                 Write site rates and categories to .rate file
  -wsl                 Write site log-likelihoods to .sitelh file
  -wslr                Write site log-likelihoods per rate category
  -wslm                Write site log-likelihoods per mixture class
  -wslmr               Write site log-likelihoods per mixture+rate class
  -wspr                Write site probabilities per rate category
  -wspm                Write site probabilities per mixture class
  -wspmr               Write site probabilities per mixture+rate class
  -wpl                 Write partition log-likelihoods to .partlh file
  -fconst f1,...,fN    Add constant patterns into alignment (N=#nstates)
  -me <epsilon>        LogL epsilon for parameter estimation (default 0.01)
  -*no-outfiles        Suppress printing output files
 -->
<!-- To maintain IQ-TREE, support users and secure fundings, it is important for us that you cite the following papers, whenever the corresponding features were applied for your analysis.
Example 1: "...We obtained branch supports with the ultrafast bootstrap (Minh et al. 2013) implemented in the IQ-TREE software (Nguyen et al. 2015)..." 

 Example 2: "...We inferred the maximum-likelihood tree using the edge-linked partition model in IQ-TREE (Chernomor et al. 2016; Nguyen et al. 2015)..." 


General Options:

Usage and meaning

-h or -? Print help usage. 

-s Specify input alignment file in PHYLIP, FASTA, NEXUS, CLUSTAL or MSF format. 

-st Specify sequence type as either of DNA, AA, BIN, MORPH, CODON or NT2AA for DNA, amino-acid, binary, morphological, codon or DNA-to-AA-translated sequences. This is only necessary if IQ-TREE did not detect the sequence type correctly. Note that -st CODON is always necessary when using codon models (otherwise, IQ-TREE applies DNA models) and you also need to specify a genetic code like this if differed from the standard genetic code. -st NT2AA tells IQ-TREE to translate protein-coding DNA into AA sequences and then subsequent analysis will work on the AA sequences. You can also use a genetic code like -st NT2AA5 for the Invertebrate Mitochondrial Code (see genetic code table). 

-t Specify a file containing starting tree for tree search. The special option -t BIONJ starts tree search from BIONJ tree and -t RANDOM starts tree search from completely random tree. DEFAULT: 100 parsimony trees + BIONJ tree 

-te Like -t but fixing user tree. That means, no tree search is performed and IQ-TREE computes the log-likelihood of the fixed user tree. 

-o Specify an outgroup taxon name to root the tree. The output tree in .treefile will be rooted accordingly. DEFAULT: first taxon in alignment 

-pre Specify a prefix for all output files. DEFAULT: either alignment file name (-s) or partition file name (-q, -spp or -sp) 

-nt Specify the number of CPU cores for iqtree-omp version. A special option -nt AUTO will tell IQ-TREE to automatically determine the best number of cores given the current data and computer. 

-seed Specify a random number seed to reproduce a previous run. This is normally used for debugging purposes. DEFAULT: based on current machine clock 

-v Turn on verbose mode for printing more messages to screen. This is normally used for debugging purposes. DFAULT: OFF 

-quiet Silent mode, suppress printing to the screen. Note that .log file is still written. 

-keep-ident Keep identical sequences in the alignment. Bu default: IQ-TREE will remove them during the analysis and add them in the end. 

-safe Turn on safe numerical mode to avoid numerical underflow for large data sets with many sequences (typically in the order of thousands). This mode is automatically turned on when having more than 2000 sequences. 

-mem Specify maximal RAM usage, for example, -mem 64G to use at most 64 GB of RAM. By default, IQ-TREE will try to not to exceed the computer RAM size. 
 
Restarting:

Option

Usage and meaning

-redo Redo the entire analysis no matter if it was stopped or successful. WARNING: This option will overwrite all existing output files. 

-cptime Specify the minimum checkpoint time interval in seconds (default: 20s) 
	
	
Likelihood mapping analysis

Starting with version 1.4.0, IQ-TREE implements the likelihood mapping approach (Strimmer and von Haeseler, 1997) to assess the phylogenetic information of an input alignment. The detailed results will be printed to .iqtree report file. The likelihood mapping plots will be printed to .lmap.svg and .lmap.eps files.

Compared with the original implementation in TREE-PUZZLE, IQ-TREE is much faster and supports many more substitution models (including partition and mixture models).

Usage and meaning

-lmap Specify the number of quartets to be randomly drawn. If you specify -lmap ALL, all unique quartets will be drawn, instead. 

-lmclust Specify a NEXUS file containing taxon clusters (see below for example) for quartet mapping analysis. 

-wql Write quartet log-likelihoods into .lmap.quartetlh file (typically not needed). 

-n 0 Skip subsequent tree search, useful when you only want to assess the phylogenetic information of the alignment. 

Automatic model selection
The default model (e.g., HKY+F for DNA, LG for protein data) may not fit well to the data. Therefore, IQ-TREE allows to automatically determine the 
best-fit model via a series of -m TEST... option:

Usage and meaning

-m TESTONLY Perform standard model selection like jModelTest (for DNA) and ProtTest (for protein). Moreover, IQ-TREE also works for codon, binary and morphogical data. 
-m TEST Like -m TESTONLY but immediately followed by tree reconstruction using the best-fit model found. So this performs both model selection and tree inference within a single run. 
-m TESTNEWONLY or -m MF Perform an extended model selection that additionally includes FreeRate model compared with -m TESTONLY. Recommended as replacement for -m TESTONLY. Note that LG4X is a FreeRate model, but by default is not included because it is also a protein mixture model. To include it, use -madd option (see table below). 
-m TESTNEW or -m MFP Like -m MF but immediately followed by tree reconstruction using the best-fit model found. 
-m TESTMERGEONLY Select best-fit partitioning scheme like PartitionFinder. 
-m TESTMERGE Like -m TESTMERGEONLY but immediately followed by tree reconstruction using the best partitioning scheme found. 
-m TESTNEWMERGEONLY or -m MF+MERGE Like -m TESTMERGEONLY but additionally includes FreeRate model. 
-m TESTNEWMERGE or -m MFP+MERGE Like -m MF+MERGE but immediately followed by tree reconstruction using the best partitioning scheme found. 

“TIP: During model section run, IQ-TREE will write a file with suffix .model that stores information of all models tested so far. Thus, if IQ-TREE is interrupted for whatever reason, restarting the run will load this file to reuse the computation. Thus, this file acts like a checkpoint to resume the model selection.

Several parameters can be set to e.g. reduce computations:

Option

Usage and meaning

-rcluster Specify the percentage for the relaxed clustering algorithm (Lanfear et al., 2014). This is similar to -*rcluster-percent option of PartitionFinder. For example, with -rcluster 10 only the top 10% partition schemes are considered to save computations. 
-mset Specify the name of a program (raxml, phyml or mrbayes) to restrict to only those models supported by the specified program. Alternatively, one can specify a comma-separated list of base models. For example, -mset WAG,LG,JTT will restrict model selection to WAG, LG, and JTT instead of all 18 AA models to save computations. 
-msub Specify either nuclear, mitochondrial, chloroplast or viral to restrict to those AA models designed for specified source. 
-mfreq Specify a comma-separated list of frequency types for model selection. DEFAULT: -mfreq FU,F for protein models (FU = AA frequencies given by the protein matrix, F = empirical AA frequencies from the data), -mfreq ,F1x4,F3x4,F for codon models 
-mrate Specify a comma-separated list of rate heterogeneity types for model selection. DEFAULT: -mrate E,I,G,I+G for standard procedure, -mrate E,I,G,I+G,R for new selection procedure 
-cmin Specify minimum number of categories for FreeRate model. DEFAULT: 2 
-cmax Specify maximum number of categories for FreeRate model. It is recommended to increase if alignment is long enough. DEFAULT: 10 
-merit Specify either AIC, AICc or BIC for the optimality criterion to apply for new procedure. DEFAULT: all three criteria are considered 
-mtree Turn on full tree search for each model considered, to obtain more accurate result. Only recommended if enough computational resources are available. DEFAULT: fixed starting tree 
-mredo Ignore .model file computed earlier. DEFAULT: .model file (if exists) is loaded to reuse previous computations 
-madd Specify a comma-separated list of mixture models to additionally consider for model selection. For example, -madd LG4M,LG4X to additionally include these two protein mixture models. 
-mdef Specify a NEXUS model file to define new models. 

“NOTE: Some of the above options require a comma-separated list, which should not contain any empty space!

Example usages:

•Select best-fit model for alignment data.phy based on Bayesian information criterion (BIC):
  iqtree -s data.phy -m TESTONLY

•Select best-fit model for a protein alignment prot.phy using the new testing procedure and only consider WAG, LG and JTT matrix to save time:
  iqtree -s prot.phy -m MF -mset WAG,LG,JTT
  
Specifying substitution models
-m is a powerful option to specify substitution models, state frequency and rate heterogeneity type. The general syntax is:
-m MODEL+FreqType+RateType

where MODEL is a model name, +FreqType (optional) is the frequency type and +RateType (optional) is the rate heterogeneity type.

The following MODELs are available:

DataType

Model names
DNA JC/JC69, F81, K2P/K80, HKY/HKY85, TN/TrN/TN93, TNe, K3P/K81, K81u, TPM2, TPM2u, TPM3, TPM3u, TIM, TIMe, TIM2, TIM2e, TIM3, TIM3e, TVM, TVMe, SYM, GTR and 6-digit specification. See DNA models for more details. 
Protein BLOSUM62, cpREV, Dayhoff, DCMut, FLU, HIVb, HIVw, JTT, JTTDCMut, LG, mtART, mtMAM, mtREV, mtZOA, Poisson, PMB, rtREV, VT, WAG. 
Protein Mixture models: C10, …, C60 (CAT model) (Lartillot and Philippe, 2004), EX2, EX3, EHO, UL2, UL3, EX_EHO, LG4M, LG4X, CF4. See Protein models for more details. 
Codon MG, MGK, MG1KTS, MG1KTV, MG2K, GY, GY1KTS, GY1KTV, GY2K, ECMK07/KOSI07, ECMrest, ECMS05/SCHN05 and combined empirical-mechanistic models. See Codon models for more details. 
Binary JC2, GTR2. See Binary and morphological models for more details. 
Morphology MK, ORDERED. See Binary and morphological models for more details. 

The following FreqTypes are supported: FreqType

Meaning
+F Empirical state frequency observed from the data. 
+FO State frequency optimized by maximum-likelihood from the data. Note that this is with letter-O and not digit-0. 
+FQ Equal state frequency. 
+F1x4 See Codon frequencies. 
+F3x4 See Codon frequencies. 

Usage and meaning
-mwopt Turn on optimizing weights of mixture models. Note that for models like LG+C20+F+G this mode is automatically turned on, but not for LG+C20+G. 

Example usages:

•Infer an ML tree for a DNA alignment dna.phy under GTR+I+G model:
  iqtree -s dna.phy -m GTR+I+G


Rate heterogeneity - The following RateTypes are supported:
RateType

+I Allowing for a proportion of invariable sites. 
+G Discrete Gamma model (Yang, 1994) with default 4 rate categories. The number of categories can be changed with e.g. +G8. 
+I+G Invariable site plus discrete Gamma model (Gu et al., 1995). 
+R FreeRate model (Yang, 1995; Soubrier et al., 2012) that generalizes +G by relaxing the assumption of Gamma-distributed rates. The number of categories can be specified with e.g. +R6. DEFAULT: 4 categories 
+I+R invariable site plus FreeRate model. 

See Rate heterogeneity across sites for more details.

Further options:
Usage and meaning

-a Specify the Gamma shape parameter (default: estimate) 
-gmedian Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994) 
-i Specify the proportion of invariable sites (default: estimate) 
-*opt-gamma-inv Perform more thorough estimation for +I+G model parameters 
-wsr Write per-site rates to .rate file 

Optionally, one can specify Ascertainment bias correction by appending +ASC to the model string. Advanced mixture models can also be specified via MIX{...} and FMIX{...} syntax. Option -mwopt can be used to turn on optimizing weights of mixture models.

Partition model options - Partition models are used for phylogenomic data with multiple genes. You first have to prepare a partition file in NEXUS or RAxML-style format. Then use the following options to input the partition file:
Usage and meaning

-q Specify partition file for edge-equal partition model. That means, all partitions share the same set of branch lengths (like -q option of RAxML). 
-spp Like -q but allowing partitions to have different evolutionary speeds (edge-proportional partition model). 
-sp Specify partition file for edge-unlinked partition model. That means, each partition has its own set of branch lengths (like -M option of RAxML). This is the most parameter-rich partition model to accomodate heterotachy. 

Site-specific frequency model options - The site-specific frequency model is used to substantially reduce the time and memory requirement compared with full profile mixture models C10 to C60. For full details see site-specific frequency model. To use this model you have to specify a profile mixture model with e.g. -m LG+C20+F+G together with a guide tree or a site frequency file:

Option

Usage and meaning

-ft Specify a guide tree (in Newick format) to infer site frequency profiles. 
-fs Specify a site frequency file, e.g. the .sitefreq file obtained from -ft run. This will save memory used for the first phase of the analysis. 
-fmax Switch to posterior maximum mode for obtaining site-specific profiles. Default: posterior mean. 

With -fs option you can input a file containing your own site frequency profiles. The format of this file is that each line contains the site ID (starting from 1) and the state frequencies (20 for amino-acid) separated by white space. So it has as many lines as the number of sites in the alignment. The order of amino-acids is:
 A   R   N   D   C   Q   E   G   H   I   L   K   M   F   P   S   T   W   Y   V


Tree search parameters - The new IQ-TREE search algorithm (Nguyen et al., 2015) has several parameters that can be changed with:
Usage and meaning

-ninit Specify number of initial parsimony trees. DEFAULT: 100. Here the PLL library (Flouri et al., 2015) is used, which implements the randomized stepwise addition and parsimony subtree pruning and regafting (SPR). 
-ntop Specify number of top initial parsimony trees to optimize with ML nearest neighbor interchange (NNI) search to initialize the candidate set. DEFAULT: 20 
-nbest Specify number of trees in the candidate set to maintain during ML tree search. DEFAULT: 5 
-nstop Specify number of unsuccessful iterations to stop. DEFAULT: 100 
-n Specify number of iterations to stop. This option overrides -nstop criterion. 
-sprrad Specify SPR radius for the initial parsimony tree search. DEFAULT: 6 
-pers Specify perturbation strength (between 0 and 1) for randomized NNI. DEFAULT: 0.5 
-allnni Turn on more thorough and slower NNI search. It means that IQ-TREE will consider all possible NNIs instead of only those in the vicinity of previously applied NNIs. DEFAULT: OFF 
-djc Avoid computing ML pairwise distances and BIONJ tree. 
-g Specify a topological constraint tree file in NEWICK format. The constraint tree can be a multifurcating tree and need not to include all taxa. 

“NOTE: While the default parameters were empirically determined to work well under our extensive benchmark (Nguyen et al., 2015), it might not hold true for all data sets. If in doubt that tree search is still stuck in local optima, one should repeat analysis with at least 10 IQ-TREE runs. Moreover, our experience showed that -pers and -nstop are the most relevant options to change in such case. For example, data sets with many short sequences should be analyzed with smaller perturbation strength (e.g. -pers 0.2) and larger number of stop iterations (e.g. -nstop 500).

Example usages:

•Infer an ML tree for an alignment data.phy with increased stopping iteration of 500 and reduced perturbation strength of 0.2:
  iqtree -s data.phy -m TEST -nstop 500 -pers 0.2

•Infer an ML tree for an alignment data.phy obeying a topological constraint tree constraint.tree:
  iqtree -s data.phy -m TEST -g constraint.tree



Ultrafast bootstrap parameters - The ultrafast bootstrap (UFBoot) approximation (Minh et al., 2013) has several parameters that can be changed with:

Usage and meaning

-bb Specify number of bootstrap replicates (>=1000). 
-wbt Turn on writing bootstrap trees to .ufboot file. DEFAULT: OFF 
-wbtl Like -wbt but bootstrap trees written with branch lengths. DEFAULT: OFF 
-nm Specify maximum number of iterations to stop. DEFAULT: 1000 
-bcor Specify minimum correlation coefficient for UFBoot convergence criterion. DEFAULT: 0.99 
-nstep Specify iteration interval checking for UFBoot convergence. DEFAULT: every 100 iterations 
-beps Specify a small epsilon to break tie in RELL evaluation for bootstrap trees. DEFAULT: 0.5 
-bspec Specify the resampling strategies for partitioned analysis. By default, IQ-TREE resamples alignment sites within partitions. With -bspec GENE IQ-TREE will resample partitions. With -bspec GENESITE IQ-TREE will resample partitions and then resample sites within resampled partitions (Gadagkar et al., 2005). 

Example usages:

•Select best-fit model, infer an ML tree and perform ultrafast bootstrap with 1000 replicates:
  iqtree -s data.phy -m TEST -bb 1000

•Reconstruct ML and perform ultrafast bootstrap (5000 replicates) under a partition model file partition.nex:
  iqtree -s data.phy -spp partition.nex -m TEST -bb 5000

Nonparametric bootstrap - The slow standard nonparametric bootstrap (Felsenstein, 1985) can be run with:

Usage and meaning

-b Specify number of bootstrap replicates (recommended >=100). This will perform both bootstrap and analysis on original alignment and provide a consensus tree. 
-bc Like -b but omit analysis on original alignment. 
-bo Like -b but only perform bootstrap analysis (no analysis on original alignment and no consensus tree). 

Single branch tests - The following single branch tests are faster than all bootstrap analysis and recommended for extremely large data sets (e.g., >10,000 taxa):

-alrt Specify number of replicates (>=1000) to perform SH-like approximate likelihood ratio test (SH-aLRT) (Guindon et al., 2010). If number of replicates is set to 0 (-alrt 0), then the parametric aLRT test (Anisimova and Gascuel 2006) is performed, instead of SH-aLRT. 
-abayes Perform approximate Bayes test (Anisimova et al., 2011). 
-lbp Specify number of replicates (>=1000) to perform fast local bootstrap probability method (Adachi and Hasegawa, 1996). 

“TIP: One can combine all these tests (also including UFBoot -bb option) within a single IQ-TREE run. Each branch in the resulting tree will be assigned several support values separated by slash (/), where the order of support values is stated in the .iqtree report file.


Example usages:

•Infer an ML tree and perform SH-aLRT test as well as ultrafast bootstrap with 1000 replicates:
  iqtree -s data.phy -m TEST -alrt 1000 -bb 1000

Tree topology tests - IQ-TREE provides a number of tests for significant topological differences between trees:

Usage and meaning
-z Specify a file containing a set of trees. IQ-TREE will compute the log-likelihoods of all trees. 
-zb Specify the number of RELL (Kishino et al., 1990) replicates (>=1000) to perform several tree topology tests for all trees passed via -z. The tests include bootstrap proportion (BP), KH test (Kishino and Hasegawa, 1989), SH test (Shimodaira and Hasegawa, 1999) and expected likelihood weights (ELW) (Strimmer and Rambaut, 2002). 
-zw Used together with -zb to additionally perform the weighted-KH and weighted-SH tests. 
-au Used together with -zb to additionally perform the approximately unbiased (AU) test (Shimodaira, 2002). Note that you have to specify the number of replicates for the AU test via -zb. 
-n 0 Only estimate model parameters on an initial parsimony tree and ignore a full tree search to save time. 
-te Specify a fixed user tree to estimate model parameters. Thus it behaves like -n 0 but uses a user-defined tree instead of parsimony tree. 

“NOTE: The AU test implementation in IQ-TREE is much more efficient than the original CONSEL by supporting SSE, AVX and multicore parallelization. Moreover, it is more appropriate than CONSEL for partition analysis by bootstrap resampling sites within partitions, whereas CONSEL is not partition-aware.

Example usages:

•Given alignment data.phy, test a set of trees in data.trees using AU test with 10,000 replicates:
  iqtree -s data.phy -m GTR+G -n 0 -z data.trees -zb 10000 -au 

•Same above but for a partitioned data partition.nex and additionally performing weighted test:
  iqtree -s data.phy -spp partition.nex -n 0 -z data.trees -zb 10000 -au -zw


Constructing consensus tree - IQ-TREE provides a fast implementation of consensus tree construction for post analysis:
Usage and meaning

-t Specify a file containing a set of trees. 
-con Compute consensus tree of the trees passed via -t. Resulting consensus tree is written to .contree file. 
-net Compute consensus network of the trees passed via -t. Resulting consensus network is written to .nex file. 
-minsup Specify a minimum threshold (between 0 and 1) to keep branches in the consensus tree. -minsup 0.5 means to compute majority-rule consensus tree. DEFAULT: 0 to compute extended majority-rule consensus. 
-bi Specify a burn-in, which is the number of beginning trees passed via -t to discard before consensus construction. This is useful e.g. when summarizing trees from MrBayes analysis. 
-sup Specify an input “target” tree file. That means, support values are first extracted from the trees passed via -t, and then mapped onto the target tree. Resulting tree with assigned support values is written to .suptree file. This option is useful to map and compare support values from different approaches onto a single tree. 
-suptag Specify name of a node in -sup target tree. The corresponding node of .suptree will then be assigned with IDs of trees where this node appears. Special option -suptag ALL will assign such IDs for all nodes of the target tree. 

Computing Robinson-Foulds distance - IQ-TREE provides a fast implementation of Robinson-Foulds (RF) distance computation between trees:
Usage and meaning

-t Specify a file containing a set of trees. 
-rf Specify a second set of trees. IQ-TREE computes all pairwise RF distances between two tree sets passed via -t and -rf 
-rf_all Compute all-to-all RF distances between all trees passed via -t 
-rf_adj Compute RF distances between adjacent trees passed via -t 

Example usages:

•Compute the pairwise RF distances between 2 sets of trees:
  iqtree -rf tree_set1 tree_set2

•Compute the all-to-all RF distances within a set of trees:
  iqtree -rf_all tree_set

Generating random trees - IQ-TREE provides several random tree generation models:
Usage and meaning

-r Specify number of taxa. IQ-TREE will create a random tree under Yule-Harding model with specified number of taxa 
-ru Like -r, but a random tree is created under uniform model. 
-rcat Like -r, but a random caterpillar tree is created. 
-rbal Like -r, but a random balanced tree is created. 
-rcsg Like -r, bur a random circular split network is created. 
-rlen Specify three numbers: minimum, mean and maximum branch lengths of the random tree. DEFAULT: -rlen 0.001 0.1 0.999 

Example usages:

•Generate a 100-taxon random tree into the file 100.tree under the Yule Harding model:
  iqtree -r 100 100.tree 

•Generate 100-taxon random tree with mean branch lengths of 0.2 and branch lengths are between 0.05 and 0.3:
  iqtree -r 100 -rlen 0.05 0.2 0.3 100.tree 

•Generate a random tree under uniform model:
  iqtree -ru 100 100.tree 

•Generate a random tree where taxon labels follow an alignment:
  iqtree -s example.phy -r 17 example.random.tree 

Note that, you still need to specify the -r option being equal to the number of taxa in the alignment.

Miscellaneous options

Usage and meaning

-wt Turn on writing all locally optimal trees into .treels file. DEFAULT: OFF 
-fixbr Turn on fixing branch lengths of tree passed via -t or -te. This is useful to evaluate the log-likelihood of an input tree with fixed tolopogy and branch lengths. DEFAULT: OFF 
-wsl Turn on writing site log-likelihoods to .sitelh file in TREE-PUZZLE format. Such file can then be passed on to CONSEL for further tree tests. DEFAULT: OFF 
-wslg Turn on writing site log-likelihoods per rate category. DEFAULT: OFF 
-fconst Specify a list of comma-separated integer numbers. The number of entries should be equal to the number of states in the model (e.g. 4 for DNA and 20 for protein). IQ-TREE will then add a number of constant sites accordingly. For example, -fconst 10,20,15,40 will add 10 constant sites of all A, 20 constant sites of all C, 15 constant sites of all G and 40 constant sites of all T into the alignment. 

	-->
<!-- adapted for expanse on or about 1/25/2021
The expanse wrapper is
 /expanse/projects/ngbt/home/cipres/ngbw/contrib/scripts/iqtree2_2.1.2_expanse

The CIPRES scripts should allow IQ-TREE2 2.1.2 to run on Expanse.

Rules for running IQ-TREE2 2.x.x on Expanse via the CIPRES gateway

Runs use varying numbers of cores within one standard node of Expanse depending
upon the data set.

- Ask the user for the following:

  whether the data set has amino acids (AAs)            $datatype=AA
  how many patterns are in the data set	                $specify_numpatterns
  whether the data set has more than one partition      $specify_numparts
  whether the analysis needs more than 248 GB of memory $specify_mem

  If the data set does not contain AAs, assume that it is DNA.
  
- Specify the number of threads (CIPRES_THREADSPP) and Slurm memory according
  to the following table.

    Data            Data  Data par-               Slurm    Slurm
    type        patterns    titions  Threads  partition   memory

Analysis that does not require more than 248 GB of memory

     DNA          <2,000          1        6     shared      11G
     DNA     2,000-5,999          1       12     shared      23G
     DNA    6,000-39,999          1       24     shared      46G
     DNA  40,000-299,999          1       48     shared      92G
     DNA       >=300,000          1      128    compute 

     DNA             any         >1        6     shared      11G

	  AA	     < 2,000	      1	      12	 shared	     23G
      AA     2,000-6,000          1       24     shared      46G
      AA    6,000-39,999          1       48     shared      92G
      AA        >=40,000          1      128    compute

      AA             any         >1       12     shared      23G

I did plan to implement this cost saving option that Wayne proposed as of 9/8/2021. 

     DNA          <3,000      any      no        6     shared      11G
     DNA     3,000-4,999      any      no        8     shared      15G
     DNA     5,000-6,999      any      no       12     shared      23G
     DNA    7,000-39,999      any      no       24     shared      46G
     DNA  40,000-299,999      any      no       48     shared      92G
     DNA       >=300,000      any      no      128    compute     243G

     DNA             any       >1     yes        6     shared      11G

      AA          <1,800      any      no       12     shared      23G
      AA     1,800-6,000      any      no       24     shared      46G
      AA    6,000-39,999      any      no       48     shared      92G
      AA        >=40,000      any      no      128    compute     243G

      AA             any       >1     yes       12     shared      23G


— revision as of 11/6/2023

- Specify the number of threads (CIPRES_THREADSPP) and Slurm memory
  according to the following table.

                             Data
    Data            Data     par-               Slurm    Slurm
    type        patterns  titions  Threads  partition   memory

     DNA          <5,000        1        6     shared      12G
     DNA     5,000-9,999        1       12     shared      24G
     DNA   10,000-39,999        1       24     shared      48G

 -->
<parameters>	
<!--  submission on expanse v1.6.12 -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>iqtree_invoke16</name>
						<attributes>
  						<precond>
								<language>perl</language>
								<code>$which_iqtree == 16</code>
							</precond> 
							<format>
								<language>perl</language>		
								<code>"iqtree_1.6.12_expanse"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>	
																										
<!--  submission on expanse v2.1.2 -->
					<parameter ismandatory="1" ishidden="1" type="String">
						<name>iqtree_invoke212</name>
						<attributes>
  						<precond>
								<language>perl</language>
								<code>$which_iqtree == 212</code>
							</precond> 
							<format>
								<language>perl</language>		
								<code>"iqtree2_2.1.2_expanse"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>		
					
				<parameter ismandatory="1" ishidden="1" type="String">
						<name>iqtree_invoke240</name>
						<attributes>
  						<precond>
								<language>perl</language>
								<code>$which_iqtree == 240</code>
							</precond> 
							<format>
								<language>perl</language>		
								<code>"iqtree2_2.4.0_expanse"</code>
							</format>
							<group>0</group>
						</attributes>
					</parameter>	

<!-- begin expanse V 2.1.2 number of nodes -->	
<!-- DNA/low memory -->
<!--     Data        Data        Data par-           Slurm       Slurm
    	 type        patterns    titions    Threads  partition   memory

Analysis that does not require more than 248 GB of memory

     DNA          <3,000      any      no        6     shared      11G
     DNA     3,000-4,999      any      no        8     shared      15G
     DNA     5,000-6,999      any      no       12     shared      23G
     DNA    7,000-39,999      any      no       24     shared      46G
     DNA  40,000-299,999      any      no       48     shared      92G
     DNA       >=300,000      any      no      128    compute     243G

     DNA             any       >1     yes        6     shared      11G-->
 
<!-- 

                             Data
    Data            Data     par-               Slurm    Slurm
    type        patterns  titions  Threads  partition   memory

     DNA          <5,000        1        6     shared      12G

-->								
				<parameter type="String" ishidden="1" >
					<name>number_nodes212a</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &lt; 5000  &amp;&amp;  !defined $partition_file  </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"mem=12G\\n" .
 									"threads_per_process=6\\n"  
							</code>
						</format>
					</attributes>
				</parameter>
				
<!--  
                                      Data
    Data            Data     par-               Slurm    Slurm
    type        patterns  titions  Threads  partition   memory

     DNA     5,000-9,999        1       12     shared      24G
 -->
				<parameter type="String" ishidden="1" >
					<name>number_nodes212c</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 4999 &amp;&amp; $specify_numpatterns &lt; 10000   &amp;&amp;  !defined $partition_file </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"mem=24G\\n" .
 									"threads_per_process=12\\n"  
							</code>
						</format>
					</attributes>
				</parameter>
				
<!--     
                             Data
    Data            Data     par-               Slurm    Slurm
    type        patterns  titions  Threads  partition   memory

     DNA   10,000-39,999        1       24     shared      48G
 -->
				<parameter type="String" ishidden="1" >
					<name>number_nodes212d</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 9999  &amp;&amp; $specify_numpatterns &lt; 40000    &amp;&amp;  !defined $partition_file</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"mem=48G\\n" .
 									"threads_per_process=24\\n"  
							</code>
						</format>
					</attributes>
				</parameter>

<!--      	DNA  40,000-299,999          1        48       shared      92G -->				
				<parameter type="String" ishidden="1" >
					<name>number_nodes212e</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype ne "PROTEIN" &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999  &amp;&amp; $specify_numpatterns &lt; 300000   &amp;&amp;  !defined $partition_file</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"mem=96G\\n" .
 									"threads_per_process=48\\n"  
							</code>
						</format>
					</attributes>
				</parameter>

<!--  	DNA       >=300,000          1       128       compute  -->				
				<parameter type="String" ishidden="1" >
					<name>number_nodes212f</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype ne "PROTEIN" &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 299999   &amp;&amp;  !defined $partition_file </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=1\\n" .
									"mem=243G\\n" .
 									"threads_per_process=128\\n"  
							</code>
						</format>
					</attributes>
				</parameter>
				
<!--      	DNA             any         >1        6     shared      11G -->
				<parameter type="String" ishidden="1" >
					<name>number_nodes212g</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype ne "PROTEIN" &amp;&amp; defined $partition_file &amp;&amp; !$more_memory &amp;&amp; !$more_memory2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"mem=11G\\n" .
 									"threads_per_process=6\\n"  
							</code>
						</format>
					</attributes>
				</parameter>	 	
				
<!-- any run with more memory needed -->
				<parameter type="String" ishidden="1" >
					<name>number_nodes212h</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$more_memory &amp;&amp; !$more_memory2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"more_memory=4\\n" .
									"node_exclusive=0\\n" .
									"mem=96G\\n" .
 									"threads_per_process=48\\n"  
							</code>
						</format>
					</attributes>
				</parameter>
				
<!--  still more -->
<!-- any run with more memory needed -->
				<parameter type="String" ishidden="1" >
					<name>number_nodes212i</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$more_memory2</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=1\\n" .
									"mem=243G\\n" .
 									"threads_per_process=128\\n"  
							</code>
						</format>
					</attributes>
				</parameter>

<!-- begin protein data; low mem -->
<!--       AA          <2,000          1       12     shared      23G -->
				<parameter type="String" ishidden="1" >
					<name>number_nodes212protx</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype eq "PROTEIN"  &amp;&amp; !$more_memory &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &lt; 1800   &amp;&amp;  !defined $partition_file</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"mem=23G\\n" .
 									"threads_per_process=12\\n"  
							</code>
						</format>
					</attributes>
				</parameter>		

<!--       AA      >2000    <6,000          1       24     shared      46G -->								
				<parameter type="String" ishidden="1" >
					<name>number_nodes212prota</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype eq "PROTEIN"  &amp;&amp; !$more_memory   &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 1799  &amp;&amp; $specify_numpatterns &lt; 6000   &amp;&amp;  !defined $partition_file</code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"mem=46G\\n" .
 									"threads_per_process=24\\n"  
							</code>
						</format>
					</attributes>
				</parameter>				

<!--   AA    6,000-39,999          1       48     shared      92G -->									
				<parameter type="String" ishidden="1" >
					<name>number_nodes212protb</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype eq "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 5999   &amp;&amp; $specify_numpatterns &lt; 40000   &amp;&amp;  !defined $partition_file </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"mem=96G\\n" .
 									"threads_per_process=48\\n"  
							</code>
						</format>
					</attributes>
				</parameter>	
							
<!--   AA        >=40,000          1      128    compute -->
				<parameter type="String" ishidden="1" >
					<name>number_nodes212protc</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype eq "PROTEIN" &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999   &amp;&amp;  !defined $partition_file </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=1\\n" .
									"mem=243G\\n" .
 									"threads_per_process=128\\n"  
							</code>
						</format>
					</attributes>
				</parameter>

 <!--  AA             any         >1       12     shared      23G					-->									
				<parameter type="String" ishidden="1" >
					<name>number_nodes212protd</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$datatype eq "PROTEIN" &amp;&amp; defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"mem=23G\\n" .
 									"threads_per_process=12\\n"  
							</code>
						</format>
					</attributes>
				</parameter> 

<!-- high memory DEPRECATED OPTION -->
<!-- Analysis that requires more than 248 GB of memory

     any             any        any      128     large-    2000G
                                                 shared 			
				<parameter type="String" ishidden="1" >
					<name>number_nodes212himem</name>
					<attributes>
						<group>2</group>
						<paramfile>scheduler.conf</paramfile>
 						<precond>
							<language>perl</language>
							<code>$specify_mem &gt; 248 </code>
						</precond>
						<format>
							<language>perl</language>
							<code>
									"nodes=1\\n" .
									"node_exclusive=0\\n" .
									"large_data=1\\n" .
									"mem=2000G\\n" .
 									"threads_per_process=128\\n"  
							</code>
						</format>
					</attributes>
				</parameter> -->	
				
<!-- input file specification -->
	<parameter ismandatory="1" issimple="1" isinput="1" type="InFile"> 
	<name>infile</name>
		<attributes>
			<prompt>Input Alignment</prompt>
			<filenames>infile.txt</filenames>
		</attributes>
	</parameter>
	
	<!-- input file specification -->
	<parameter ishidden="1"  type="String"> 
	<name>infile_conditional</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>!$mixed_sequence &amp;&amp; !$specify_commandline</code>
			</precond>
   			<format>
				<language>perl</language>
				<code>"-s infile.txt"</code>
			</format>
			<group>1</group>
		</attributes>
	</parameter>		
	
<!-- begin visible parameters -->		
<!-- This section provides visible queries that help configure the interface  -->

<!-- this sets the run time -->
				<parameter type="Float" issimple="1" ismandatory="1">
					<name>runtime</name> 
					<attributes>
						<group>90</group>
						<paramfile>scheduler.conf</paramfile>
						<prompt>Maximum Hours to Run (up to 168 hours)</prompt>
						<vdef>
							<value>0.5</value>
						</vdef>
						<ctrls>
							<ctrl>
								<message>The maximum hours to run must be less than 168</message>
								<language>perl</language>
								<code>$runtime &gt; 168.0</code>
							</ctrl>
							<ctrl>
								<message>The maximum hours to run must be greater than 0.05</message>
								<language>perl</language>
								<code>$runtime &lt; 0.05</code>
							</ctrl>
						</ctrls>
						<format>
							<language>perl</language>
							<code>"runhours=$value\\n"</code>
						</format>
<!-- Expanse all versions -->
<!-- provide feedback on number of cpu hrs to be consumed; all runs are the same, but this must be keyed to a visible param, so here we make it conditional on a non-zero run time. -->
						<warns>
<!-- all more memory and more memory2 options -->
 						<warn>
							<message>As configured this job will run on 48 processors as configured; if it runs for the entire configured time it will be charged 48 x $runtime cpu hours </message>
							 <language>perl</language>
								<code>$more_memory &amp;&amp; !$more_memory2</code>
							</warn>
							<warn>
							<message>As configured this job will require a full node. If it runs for the entire configured time, it will consume128 x $runtime cpu hours </message>
							 <language>perl</language>
								<code>$more_memory2 </code>
							</warn>
<!-- begin dna  -->
<!-- ONE PARTITION, normal memory  -->
<!-- lt 5000 -->
							<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>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &lt; 5000 &amp;&amp;  !defined $partition_file  </code>
							</warn>
<!-- 5000 - 10000  -->
							<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>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 4999 &amp;&amp; $specify_numpatterns &lt; 10000  &amp;&amp;  !defined $partition_file  </code>
							</warn>
<!-- 10000 - 40000  -->
							<warn>
								<message>The job will run on 24 processors as configured. If it runs for the entire configured time, it will consume 24 x $runtime cpu hours</message>							
								<language>perl</language>
								<code>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 9999  &amp;&amp; $specify_numpatterns &lt; 40000 &amp;&amp;  !defined $partition_file  </code>
							</warn>
<!-- 40000 - 300000  -->							
							<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>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999  &amp;&amp; $specify_numpatterns &lt; 300000 &amp;&amp;  !defined $partition_file   </code>							
							</warn>
<!-- 300000+  -->								
							<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>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 299999 &amp;&amp;  !defined $partition_file    </code>							
							</warn>
<!-- 300000+ ; TIME Warning -->									
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 3,000 - 6,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 299999   &amp;&amp; $runtime &gt;= 24 &amp;&amp; $runtime &lt;= 48 &amp;&amp;  !defined $partition_file  </code>							
							</warn>
<!-- 300000+ ; TIME Warning -->								
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 6,000 - 9,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 299999   &amp;&amp; $runtime &gt; 48 &amp;&amp; $runtime &lt;= 72 &amp;&amp;  !defined $partition_file  </code>							
							</warn> 
<!-- 300000+ ; TIME Warning -->								
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 9,000 - 12,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 299999   &amp;&amp; $runtime &gt; 72 &amp;&amp; $runtime &lt;= 96 &amp;&amp;  !defined $partition_file  </code>							
							</warn>  
<!-- 300000+ ; TIME Warning -->									
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 12,000 - 15,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 299999   &amp;&amp; $runtime &gt; 96 &amp;&amp; $runtime &lt;= 120 &amp;&amp;  !defined $partition_file  </code>							
							</warn>  
<!-- 300000+ ; TIME Warning -->		
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 15,000 - 18,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype ne "PROTEIN" &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 299999   &amp;&amp; $runtime &gt; 120 &amp;&amp; $runtime &lt;= 144 &amp;&amp;  !defined $partition_file  </code>							
							</warn>  
<!-- 300000+ ; TIME Warning -->		
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 18,000 - 21,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype ne "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 299999   &amp;&amp; $runtime &gt; 144 &amp;&amp; $runtime &lt;= 168 &amp;&amp;  !defined $partition_file  </code>							
							</warn> 
<!-- dna >1 partition--> 
							<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>$datatype ne "PROTEIN" &amp;&amp; defined $partition_file  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 </code>							
							</warn>
<!-- begin protein  -->

<!-- protein 1 partition-->
<!-- lt 1800 -->
							<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>$datatype eq "PROTEIN"   &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &lt; 1800  &amp;&amp;  !defined $partition_file  </code>						
							</warn>
<!-- 1800 - 6000 -->
							<warn>
								<message>The job will run on 24 processors as configured. If it runs for the entire configured time, it will consume 24 x $runtime cpu hours</message>	
								<language>perl</language>
								<code>$datatype eq "PROTEIN"   &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 1799  &amp;&amp; $specify_numpatterns &lt; 6000   &amp;&amp;  !defined $partition_file  </code>						
							</warn>
<!-- 6000 - 40000-->
							<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>$datatype eq "PROTEIN"   &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 5999   &amp;&amp; $specify_numpatterns &lt; 40000  &amp;&amp;  !defined $partition_file  </code>						
							</warn>
<!-- 40000 + -->
							<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>$datatype eq "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999 &amp;&amp;  !defined $partition_file   </code>						
							</warn>
<!-- protein >2 partitions-->
							<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>$datatype eq "PROTEIN"   &amp;&amp; !$more_memory &amp;&amp;  defined $partition_file  </code>						
							</warn>
<!-- 40000 + protein time warning ]-->
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 3,000 - 6,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype eq "PROTEIN"   &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999  &amp;&amp; $runtime &gt;= 24 &amp;&amp; $runtime &lt;= 48  &amp;&amp;  !defined $partition_file  </code>							
							</warn>
<!--  40000 + protein time warning ]-->
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 6,000 - 9,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype eq "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999  &amp;&amp; $runtime &gt; 48 &amp;&amp; $runtime &lt;= 72  &amp;&amp;  !defined $partition_file  </code>							
							</warn> 
<!-- 40000 + protein time warning ]-->
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 9,000 - 12,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype eq "PROTEIN" &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999  &amp;&amp; $runtime &gt; 72 &amp;&amp; $runtime &lt;= 96  &amp;&amp;  !defined $partition_file  </code>							
							</warn>  
<!-- 40000 + protein time warning ]-->
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 12,000 - 15,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype eq "PROTEIN"   &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999  &amp;&amp; $runtime &gt; 96 &amp;&amp; $runtime &lt;= 120  &amp;&amp;  !defined $partition_file  </code>							
							</warn>  
<!-- 40000 + protein time warning ]-->
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 15,000 - 18,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype eq "PROTEIN"   &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999  &amp;&amp; $runtime &gt; 120 &amp;&amp; $runtime &lt;= 144  &amp;&amp;  !defined $partition_file  </code>							
							</warn>
<!-- 40000 + protein time warning ]-->  
							<warn>
								<message>WARNING: If your job runs for the full configured time, it will consume 18,000 - 21,000 cpu hours. Please consider if you want to do this.</message>
								<language>perl</language>
								<code>$datatype eq "PROTEIN"  &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999  &amp;&amp; $runtime &gt; 144 &amp;&amp; $runtime &lt;= 168  &amp;&amp;  !defined $partition_file  </code>							
							</warn>       
						</warns>
						<comment>
<value>Estimate the maximum time your job will need to run. We recommend testing 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>
					</attributes>
				</parameter>
				
<!-- which iq treeHi Mark,

I installed and tested Version 2.4.0 of IQ-TREE2 on Expanse. It is no faster than 2.3.2 and 2.3.6, but I think we should remove those two older versions from those offered by CIPRES and offer 2.4.0 to take advantage of bug fixes and new features.

* Please work with Mark Z to make 2.4.0 available via CIPRES in addition to 1.6.12 and 2.1.2. The latter is important to keep, since it is faster than 2.4.0.

The wrapper for 2.4.0 is

  iqtree2_2.4.0_expanse .

Thanks,
Wayne
 -->	
	<parameter  issimple="1" ismandatory="1" type="Excl"> 
	<name>which_iqtree</name>
		<attributes>
			<prompt>Which version do you want to run?</prompt>
			<vlist>
  				<value>16</value>
				<label>1.6.12</label> 
				<value>212</value>
				<label>2.1.2</label>
				<value>240</value>
				<label>2.4.0</label>
			</vlist>
			<vdef>	
				<value>240</value>
			</vdef>
			<ctrls>
				<ctrl>
					<message>Please choose an IQ Tree version</message>
					<language>perl</language>
					<code>!defined $which_iqtree</code>
				</ctrl>
			</ctrls>
		</attributes>
	</parameter>
	
<!-- specify num patterns -->			
	<parameter issimple="1" type="Integer"> 
	<name>specify_numpatterns</name>
		<attributes>
			<prompt>How many patterns does your data set have?</prompt>
			<ctrls>
				<ctrl>
					<message>Please specify the number of patterns</message>
					<language>perl</language>
					<code>!defined $specify_numpatterns</code>
				</ctrl>
				<ctrl>
					<message>The number of patterns must be greater than zero</message>
					<language>perl</language>
					<code>$specify_numpatterns &lt; 1</code>
				</ctrl>
				<ctrl>
					<message>Please specify the number of patterns</message>
					<language>perl</language>
					<code>!defined $specify_numpatterns</code>
				</ctrl>
			</ctrls>
			<comment>
<value>You can do a quick run, and the output log will tell you how many patterns are in your data set.</value>
			</comment>
		</attributes>
	</parameter>

	<parameter  issimple="1" type="Switch"> 
	<name>more_memory</name>
		<attributes>
			<prompt>I need more memory</prompt>
 		<!--<precond>
				<language>perl</language>
				<code>$datatype ne "PROTEIN"</code>
			</precond>	-->
			<comment>
				<value>This option should only be used if analysis has run out of memory</value>
			</comment>
		</attributes>
	</parameter>
	
	<parameter  issimple="1" type="Switch"> 
	<name>more_memory2</name>
		<attributes>
			<prompt>I need still more memory</prompt>
<!--			<precond>
				<language>perl</language>
				<code>$datatype ne "PROTEIN"</code>
			</precond> -->
			<comment>
				<value>This option should only be used if analysis set with more memory has run out of memory</value>
			</comment>
		</attributes>
	</parameter>
	
<!-- allow the user to free text their command line  -->
	<parameter issimple="1" type="Switch"> 
	<name>specify_commandline</name>
		<attributes>
			<prompt>I would like to specify my commandline in free text</prompt>
		</attributes>
	</parameter> 
	
		<parameter issimple="1" type="String"> 
		<name>specify_commandline2</name>
		<attributes>
			<prompt>Please enter your commandline</prompt>
			<precond>
				<language>perl</language>
			    <code>$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"$specify_commandline2"</code>
			</format>
			<ctrls>
				<ctrl>
					<message>Please enter your commandline</message>
					<language>perl</language>
					<code>$specify_commandline &amp;&amp; !defined $specify_commandline2</code>
				</ctrl>
			</ctrls>
		</attributes>
	</parameter> 

<!--  -safe                Safe likelihood kernel to avoid numerical underflow -->
	<parameter  issimple="1" type="Switch"> 
	<name>specify_safe</name>
		<attributes>
			<prompt>Safe likelihood kernel to avoid numerical underflow (-safe)</prompt>
			<precond>
				<language>perl</language>
			    <code>!$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>($value) ? "-safe":""</code>
			</format>
			<group>29</group>
		</attributes>
	</parameter>

<!-- set up nt for all values on 1.6 	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3</name>
		<attributes>
 			<precond>
				<language>perl</language>
				<code>$datatype ne "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &lt; 3000 &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 6"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3b</name>
		<attributes>
 			<precond>
				<language>perl</language>
				<code>$datatype ne "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 2999 &amp;&amp; $specify_numpatterns &lt; 5000 &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 8"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3c</name>
		<attributes>
 			<precond>
				<language>perl</language>
				<code>$datatype ne "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 4999 &amp;&amp; $specify_numpatterns &lt; 7000 &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 12"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3d</name>
		<attributes>
	 			<precond>
					<language>perl</language>
					<code>$datatype ne "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 6999  &amp;&amp; $specify_numpatterns &lt; 40000 &amp;&amp; $which_iqtree &lt; 20 </code>
				</precond>
			<format>
				<language>perl</language>
				<code>"-nt 24"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>

	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3e</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>$datatype ne "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999  &amp;&amp; $specify_numpatterns &lt; 300000 &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 48"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
		
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3f</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>$datatype ne "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 299999 &amp;&amp; $which_iqtree &lt; 20  </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 128"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>-->

<!-- reg mem with partition
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3gb</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>!$more_memory &amp;&amp; $datatype ne "PROTEIN" &amp;&amp; defined $partition_file &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 6"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter> -->
	
<!-- -nt more mem with part file 	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3g</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>($more_memory || $more_memory2) &amp;&amp; defined $partition_file &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 24"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>-->
	
<!-- aa -nt options 
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3h</name>
		<attributes>
 			<precond>
				<language>perl</language>
				<code>$datatype eq "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &lt; 1800 &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>	
			<format>
				<language>perl</language>
				<code>"-nt 12"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3i</name>
		<attributes>
 			<precond>
				<language>perl</language>
				<code>$datatype eq "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  
				&amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 1799  &amp;&amp; $specify_numpatterns &lt; 6000 &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 24"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	
	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3j</name>
		<attributes>
 			<precond>
				<language>perl</language>
				<code>$datatype eq "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 5999   &amp;&amp; $specify_numpatterns &lt; 40000 &amp;&amp; $which_iqtree &lt; 20  </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 48"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>	


	<parameter  issimple="1" ishidden= "1" type="String"> 
	<name>specify_cores3k</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>$datatype eq "PROTEIN" &amp;&amp; !defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $specify_numpatterns &gt; 39999 &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 128"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter> -->

<!-- 
	<parameter  issimple="1" ishidden= "1" type="String"> 	
	<name>specify_cores3l</name>
		<attributes>
 			<precond>
				<language>perl</language>
				<code>$datatype eq "PROTEIN" &amp;&amp; defined $partition_file &amp;&amp; !$more_memory  &amp;&amp; !$more_memory2 &amp;&amp; $which_iqtree &lt; 20 </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-nt 12"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter> -->
	
	<!-- 	Specify run type. 
	<parameter  issimple="1" ismandatory="1" type="Excl"> 
	<name>specify_runtype</name>
		<attributes>
			<prompt>Select the kind of run you need</prompt>
			<vlist>
				<value>1</value>
				<label>Model Selection</label>
				<value>2</value>
				<label>Tree Inference</label>
			</vlist>
			<ctrls>
				<ctrl>
					<message>Please specify whether the run is for Tree inference or Model Selection</message>
					<language>perl</language>
					<code>!defined $value </code>
				</ctrl>
			</ctrls>
		</attributes>
	</parameter>-->
	
<!-- 	Sequence type
Specify sequence type as either of DNA, AA, BIN, MORPH, CODON or NT2AA for DNA, amino-acid, binary, 
morphological, codon or DNA-to-AA-translated sequences. This is only necessary if IQ-TREE did not detect 
the sequence type correctly. Note that -st CODON is always necessary when using codon models (otherwise, 
IQ-TREE applies DNA models) and you also need to specify a genetic code like this if differed from the 
standard genetic code. -st NT2AA tells IQ-TREE to translate protein-coding DNA into AA sequences and then 
subsequent analysis will work on the AA sequences. You can also use a genetic code like -st NT2AA5 for the 
Invertebrate Mitochondrial Code (see genetic code table).-->

	<parameter issimple="1"  type="Excl"> 
	<name>datatype</name>
		<attributes>
			<prompt>Specify your sequence type (-st)</prompt>
			<precond>
				<language>perl</language>
				<code>!$mixed_sequence</code>
			</precond>
			<vlist>
				<value>DNA</value>
				<label>DNA</label>
				<value>PROTEIN</value>
				<label>Amino Acid</label>
				<value>BINARY</value>
				<label>Binary</label>
				<value>MORPH</value>
				<label>Morphological</label>
				<value>CODON</value>
				<label>Codon</label>
				<value>NT2AA</value>
				<label>Translate DNA</label>
			</vlist>
		<ctrls>
				<ctrl>
					<message>Please select the sequence type</message>
					<language>perl</language>
					<code>!defined $datatype &amp;&amp; !$mixed_sequence</code>
				</ctrl>
			</ctrls> 
			<group>3</group>
		</attributes>
	</parameter>
	
	<parameter ishidden="1"  type="String"> 
	<name>datatype2</name>
		<attributes>
			<precond>
				<language>perl</language>
			<code>$datatype eq "DNA" &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-st DNA"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	
<parameter ishidden="1"  type="String"> 
	<name>datatype3</name>
		<attributes>
			<precond>
				<language>perl</language>
			<code>$datatype eq "PROTEIN" &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-st AA"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	
<parameter ishidden="1"  type="String"> 
	<name>datatype4</name>
		<attributes>
			<precond>
				<language>perl</language>
			<code>$datatype eq "BIN" &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-st BIN"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
		<parameter ishidden="1"  type="String"> 
	
	<name>datatype5</name>
		<attributes>
			<precond>
				<language>perl</language>
			<code>$datatype eq "MORPH" &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-st MORPH"</code>
			</format>
			<group>3</group>
		</attributes>
	</parameter>
	


<!-- 
CODON1 The Standard Code (same as -st CODON) 
CODON2 The Vertebrate Mitochondrial Code 
CODON3 The Yeast Mitochondrial Code 
CODON4 The Mold, Protozoan, and Coelenterate Mitochondrial Code and the Mycoplasma/Spiroplasma Code 
CODON5 The Invertebrate Mitochondrial Code 
CODON6 The Ciliate, Dasycladacean and Hexamita Nuclear Code 
CODON9 The Echinoderm and Flatworm Mitochondrial Code 
CODON10 The Euplotid Nuclear Code 
CODON11 The Bacterial, Archaeal and Plant Plastid Code 
CODON12 The Alternative Yeast Nuclear Code 
CODON13 The Ascidian Mitochondrial Code 
CODON14 The Alternative Flatworm Mitochondrial Code 
CODON16 Chlorophycean Mitochondrial Code 
CODON21 Trematode Mitochondrial Code 
CODON22 Scenedesmus obliquus Mitochondrial Code 
CODON23 Thraustochytrium Mitochondrial Code 
CODON24 Pterobranchia Mitochondrial Code 
CODON25 Candidate Division SR1 and Gracilibacteria Code 
 -->
	<parameter  issimple="1" ismandatory="1" type="Excl"> 
	<name>codon_type</name>
		<attributes>
			<prompt>Specify your Codon type</prompt>
			<precond>
				<language>perl</language>
				<code>$datatype eq "CODON" &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-st $value"</code>
			</format>
			<vlist>
				<value>CODON1</value>
				<label>The Standard Code</label>
				<value>CODON2</value>
				<label>The Vertebrate Mitochondrial Code</label>
				<value>CODON3</value>
				<label>The Yeast Mitochondrial Code</label>
				<value>CODON4</value>
				<label>Mold, Protozoan, Coelenterate, Mycoplasma/Spiroplasma </label>
				<value>CODON5</value>
				<label>The Invertebrate Mitochondrial Code</label>
				<value>CODON6</value>
				<label>The Ciliate, Dasycladacean and Hexamita Nuclear Code </label>
				<value>CODON9</value>
				<label>The Echinoderm and Flatworm Mitochondrial Code</label>
				<value>CODON10</value>
				<label>The Euplotid Nuclear Code</label>
				<value>CODON11</value>
				<label>The Bacterial, Archaeal and Plant Plastid Code</label>
				<value>CODON12</value>
				<label>The Alternative Yeast Nuclear Code</label>
				<value>CODON13</value>
				<label>The Ascidian Mitochondrial Code</label>
				<value>CODON14</value>
				<label>The Alternative Flatworm Mitochondrial Code</label>
				<value>CODON16</value>
				<label>Chlorophycean Mitochondrial Code</label>
				<value>CODON21</value>
				<label>Trematode Mitochondrial Code</label>
				<value>CODON22</value>
				<label>Scenedesmus obliquus Mitochondrial Code </label>
				<value>CODON23</value>
				<label>Thraustochytrium Mitochondrial Code</label>
				<value>CODON24</value>
				<label>Pterobranchia Mitochondrial Code</label>
				<value>CODON25</value>
				<label>Candidate Division SR1 and Gracilibacteria Code</label>
			</vlist>
			<vdef>
				<value>CODON1</value>
			</vdef>
			<ctrls>
				<ctrl>
					<message>Please specify your Codon code type</message>
					<language>perl</language>
					<code>$datatype eq "CODON" &amp;&amp; !defined $codon_type &amp;&amp; !$specify_commandline</code>
				</ctrl>
			</ctrls> 
			<group>2</group>
		</attributes>
	</parameter>
	
<!-- 
NT2AA1 The Standard Code (same as -st NT2AA) 
NT2AA2 The Vertebrate Mitochondrial Code 
NT2AA3 The Yeast Mitochondrial Code 
NT2AA4 The Mold, Protozoan, and Coelenterate Mitochondrial Code and the Mycoplasma/Spiroplasma Code 
NT2AA5 The Invertebrate Mitochondrial Code 
NT2AA6 The Ciliate, Dasycladacean and Hexamita Nuclear Code 
NT2AA9 The Echinoderm and Flatworm Mitochondrial Code 
NT2AA10 The Euplotid Nuclear Code 
NT2AA11 The Bacterial, Archaeal and Plant Plastid Code 
NT2AA12 The Alternative Yeast Nuclear Code 
NT2AA13 The Ascidian Mitochondrial Code 
NT2AA14 The Alternative Flatworm Mitochondrial Code 
NT2AA16 Chlorophycean Mitochondrial Code 
NT2AA21 Trematode Mitochondrial Code 
NT2AA22 Scenedesmus obliquus Mitochondrial Code 
NT2AA23 Thraustochytrium Mitochondrial Code 
NT2AA24 Pterobranchia Mitochondrial Code 
NT2AA25 Candidate Division SR1 and Gracilibacteria Code 
 -->
	<parameter  issimple="1" ismandatory="1" type="Excl"> 
	<name>nt2aa_type</name>
		<attributes>
			<prompt>Specify your translation table</prompt>
			<precond>
				<language>perl</language>
				<code>$datatype eq "NT2AA" &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-st $value"</code>
			</format>
			<vlist>
				<value>NT2AA1</value>
				<label>The Standard Code</label>
				<value>NT2AA2</value>
				<label>The Vertebrate Mitochondrial Code</label>
				<value>NT2AA3</value>
				<label>The Yeast Mitochondrial Code</label>
				<value>NT2AA4</value>
				<label>Mold, Protozoan, Coelenterate, Mycoplasma/Spiroplasma </label>
				<value>NT2AA5</value>
				<label>The Invertebrate Mitochondrial Code</label>
				<value>NT2AA6</value>
				<label>The Ciliate, Dasycladacean and Hexamita Nuclear Code </label>
				<value>NT2AA9</value>
				<label>The Echinoderm and Flatworm Mitochondrial Code</label>
				<value>NT2AA10</value>
				<label>The Euplotid Nuclear Code</label>
				<value>NT2AA11</value>
				<label>The Bacterial, Archaeal and Plant Plastid Code</label>
				<value>NT2AA12</value>
				<label>The Alternative Yeast Nuclear Code</label>
				<value>NT2AA13</value>
				<label>The Ascidian Mitochondrial Code</label>
				<value>NT2AA14</value>
				<label>The Alternative Flatworm Mitochondrial Code</label>
				<value>NT2AA16</value>
				<label>Chlorophycean Mitochondrial Code</label>
				<value>NT2AA21</value>
				<label>Trematode Mitochondrial Code</label>
				<value>NT2AA22</value>
				<label>Scenedesmus obliquus Mitochondrial Code </label>
				<value>NT2AA23</value>
				<label>Thraustochytrium Mitochondrial Code</label>
				<value>NT2AA24</value>
				<label>Pterobranchia Mitochondrial Code</label>
				<value>NT2AA25</value>
				<label>Candidate Division SR1 and Gracilibacteria Code</label>
			</vlist>
			<vdef>
				<value>NT2AA1</value>
			</vdef>
			<ctrls>
				<ctrl>
					<message>Please select your translation table type</message>
					<language>perl</language>
					<code>$datatype eq "NT2AA" &amp;&amp; !defined nt2aa_type &amp;&amp; !$specify_commandline</code>
				</ctrl>
			</ctrls>
			<group>2</group>
		</attributes>
	</parameter>
	
	<!-- 	specify a starting tree -->
	<parameter  issimple="1" type="InFile"> 
	<name>starting_tree</name>
		<attributes>
			<prompt>Specify a starting (or other) tree file (-t)</prompt>
			<filenames>treefile.tre</filenames>
			<group>4</group>
			<warns>
				<warn>
					<message>Note that your treefile will be named treefile.tre; your command line must include -t treefile.tre</message>
					<language>perl</language>
					<code> defined $starting_tree &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
		</attributes>
	</parameter>
	
<parameter  ishidden="1" type="String"> 
	<name>starting_tree2</name>
		<attributes>
			<prompt>Specify a starting (or other) tree file (-t)</prompt>			
			<precond>
				<language>perl</language>
				<code> !$specify_commandline &amp;&amp; defined $starting_tree </code>
			</precond>
			<format>
				<language>perl</language>
				<code> "-t treefile.tre"</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>

<!-- -t bionj starting tree -->
	<parameter  issimple="1" type="Switch"> 
	<name>use_nj</name>
		<attributes>
			<prompt>Use a NJ starting tree (-t BIONJ)</prompt>
			<precond>
				<language>perl</language>
				<code>!defined $starting_tree &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>($value) ? "-t BIONJ":"" </code>
			</format>
			<ctrls>
				<ctrl>
					<message>Sorry, you cannot choose both a random and a NJ starting tree</message>
					<language>perl</language>
					<code>$use_nj &amp;&amp; $use_random </code>
				</ctrl>
			</ctrls>
			<group>4</group>
		</attributes>
	</parameter>
	
	<!-- 	-t random starting tree -->
	<parameter  issimple="1" type="Switch"> 
	<name>use_random</name>
		<attributes>
			<prompt>Use a Random starting tree (-t RANDOM) </prompt>
			<precond>
				<language>perl</language>
				<code>!defined $starting_tree  &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>($value) ? "-t RANDOM":""</code>
			</format>
			<group>4</group>			
		</attributes>
	</parameter>
	
<!-- 	-o Specify an outgroup. -->
	<parameter  issimple="1" type="String"> 
	<name>specify_outgroup</name>
		<attributes>
			<prompt>Specify the outgroup (-o)</prompt>
			<precond>
				<language>perl</language>
				<code> !$specify_commandline &amp;&amp; !$specify_commandline</code>
			</precond>			 
			<format>
				<language>perl</language>
				<code>(defined $value) ?  "-o $value":""</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>

<!-- -pre specify prefix for output files -->
	<parameter  issimple="1" type="String"> 
	<name>specify_prefix</name>
		<attributes>
			<prompt>Specify the prefix for output files (-pre'/ --prefix)</prompt>
			<precond>
				<language>perl</language>
				<code>!$specify_commandline</code>
			</precond>
			<vdef>
				<value>output</value>
			</vdef>
			<group>30</group>
		</attributes>
	</parameter>
	
<!-- Broke this up because the commands changed -->
	<parameter  ishidden="1" type="String"> 
	<name>specify_prefix1</name>
		<attributes>
		<precond>
			<language>perl</language>
			<code>defined $specify_prefix &amp;&amp; $which_iqtree &lt; 20 </code>
		</precond>
		<format>
			<language>perl</language>
			<code>"-pre $specify_prefix"</code>
		</format>
		<group>29</group>
		</attributes>
	</parameter>
		
	<parameter  ishidden="1" type="String"> 
	<name>specify_prefix2</name>
		<attributes>
		<precond>
			<language>perl</language>
			<code>defined $specify_prefix &amp;&amp; $which_iqtree &gt; 200 </code>
		</precond>
		<format>
			<language>perl</language>
			<code>"--prefix $specify_prefix"</code>
		</format>
		<group>29</group>
		</attributes>
	</parameter>
	
<!-- -seed specify seed -->
	<parameter  issimple="1" type="Integer"> 
	<name>specify_seed</name>
		<attributes>
			<prompt>Specify a seed (-seed)</prompt>
			<precond>
				<language>perl</language>
				<code>!$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>(defined $value) ?  "-seed $value":""</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>

<parameter type="Paragraph">
<paragraph>
	<name>quartet_options</name>
		<prompt>Quartet Options</prompt>
			<parameters>

<!-- -lmap Specify the number of quartets to be randomly drawn. If you specify -lmap ALL, all unique quartets will be drawn, instead. -->
	<parameter  type="Excl"> 
	<name>specify_quartets</name>
		<attributes>
			<prompt>Quartets to be randomly drawn (-lmap)</prompt>
			<precond>
				<language>perl</language>
				<code> !$specify_commandline</code>
			</precond>
			<vlist>
				<value>ALL</value>
				<label>All</label>
				<value>specify_quartet</value>
				<label>Specify number</label>
			</vlist>
			<group>4</group>
		</attributes>
	</parameter>
	
<parameter ishidden="1" type="Integer"> 
	<name>specify_quartetall</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>$specify_quartets eq "ALL" </code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-lmap ALL"</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>
	
	<parameter type="Integer"> 
	<name>specify_quartetnum</name>
		<attributes>
			<prompt>Specify number of quartets</prompt>
			<precond>
				<language>perl</language>
				<code>$specify_quartets eq "specify_quartet"</code>
			</precond>
			<format>
				<language>perl</language>
				<code>defined $value ? "-lmap $value":""</code>
			</format>
			<ctrls>
				<ctrl>
					<message>Please specify the number of quartets</message>
					<language>perl</language>
					<code>$specify_quartets eq "specify_quartet" &amp;&amp; !defined $specify_quartetnum</code>
				</ctrl>
			</ctrls>
			<group>4</group>
		</attributes>
	</parameter>
	
<!-- -lmclust	Specify a NEXUS file containing taxon clusters (see below for example) for quartet mapping analysis.-->
	<parameter   type="InFile"> 
	<name>specify_quartetset</name>
		<attributes>
			<prompt>Select a NEXUS file specifying taxon clusters (-lmclust)</prompt>
			<filenames>clusters.nex</filenames>
			<group>4</group>
			<warns>
				<warn>
					<message>Note that your clusters file will be named clusters.nex; your command line must include -lmclust  clusters.nex</message>
					<language>perl</language>
					<code>defined $specify_quartetset &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
		</attributes>
	</parameter>	
	
<parameter ishidden="1"  type="String"> 
	<name>specify_quartetset2</name>
		<attributes>
			<precond>
				<language>perl</language>
				<code>defined $specify_quartetsets &amp;&amp;  !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code> "-lmclust clusters.nex"</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>	
	
 		 <parameter type="Integer"> 
 					<name>specify_numparsquartets</name>
 					<attributes>
 						<prompt>Specify number of parsimony-based sCF quartets (--scf)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200 &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "--scf $value":""</code>
						</format>
						<warns>
							<warn>
								<message>The authors recommend at least 100 quartets for stable values</message>
								<language>perl</language>
								<code>(defined $specify_numparsquartets) &amp;&amp; $specify_numparsquartets &lt; 100</code>
							</warn>
						</warns>
 					</attributes>
 				</parameter>
 				
 				 <parameter type="Integer"> 
 					<name>specify_numlikquartets</name>
 					<attributes>
 						<prompt>Specify number of likelihood-based ssCF quartets  (--scfl)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200 &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>"--scfl $value"</code>
						</format>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify both --scf and --scfl</message>
								<language>perl</language>
								<code>defined $specify_numlikquartets &amp;&amp; defined $specify_numparsquartets</code>
							</ctrl>
						</ctrls>
						<warns>
							<warn>
								<message>The authors recommend at least 100 quartets for stable values</message>
								<language>perl</language>
								<code>(defined $specify_numlikquartets) &amp;&amp; $specify_numlikquartets &lt; 100</code>
							</warn>
						</warns>
 					</attributes>
 				</parameter>	
	
<!-- wql	Write quartet log-likelihoods into .lmap.quartetlh file (typically not needed).	-->
	<parameter  type="Switch"> 
	<name>write_quartets</name>
		<attributes>
			<prompt>Write quartets to a file</prompt>
			<precond>
				<language>perl</language>
				<code>defined $specify_quartets &amp;&amp;  !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>$write_quartets ? "-wql":""</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>	
		</parameters>
		</paragraph>
</parameter>
	
<parameter type="Paragraph">
	<paragraph>
		<name>partition_options</name>
		<prompt>Partition Options</prompt>
			<parameters>

			<parameter type="InFile">
				<name>partition_file</name>
				<attributes>
					<prompt>Please select your partition file</prompt>
					<group>10</group>
					<filenames>partition_file.txt</filenames>
					<warns>
						<warn>
							<message>Your partition file will be named partition_file.txt, you must include this name in your commandline</message>
							<language>perl</language>
						  <code>defined $partition_file &amp;&amp; $specify_commandline</code>
						</warn>
					</warns>
				</attributes>
			</parameter>
			
			<parameter ismandatory="1" type="Switch">
				<name>nexus_partition_file</name>
				<attributes>
					<prompt>My partitions are specified in a Nexus file</prompt>
					<precond>
						<language>perl</language>
						<code>defined $partition_file</code>
					</precond>	
				</attributes>
			</parameter>
										
			<parameter ismandatory="1" type="Excl">
				<name>partition_type</name>
				<attributes>
					<prompt>Please select your partition type </prompt>
					<precond>
						<language>perl</language>
						<code>defined $partition_file &amp;&amp; !$specify_commandline </code>
					</precond>	
					<vlist>
						<value>-q</value>
						<label>Edge-equal partition model (-q)</label>
						<value>-spp</value>
						<label>Allow partitions to have different speeds (-spp or -p)</label>
						<value>-sp</value>
						<label>Edge-unlinked partition model (-sp or -Q)</label>
					</vlist>
					<ctrls>
						<ctrl>
							<message>Please specify your partition type</message>
							<language>perl</language>
							<code>!defined $partition_type &amp;&amp; defined $partition_file &amp;&amp; !$specify_commandline </code>
						</ctrl>
					</ctrls>
				</attributes>
			</parameter>
		
			<parameter ishidden="1" type="String">
				<name>partition_command2</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>defined $partition_type &amp;&amp; $which_iqtree &lt; 200 &amp;&amp; !$specify_commandline</code>
					</precond>
					<format>		
						<language>perl</language>
						<code>"$partition_type partition_file.txt"</code>
					</format>
					<group>2</group>
				</attributes>
			</parameter>		
			
			<parameter ishidden="1" type="String">
				<name>partition_command3</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>defined $partition_type &amp;&amp; $which_iqtree &gt; 200 &amp;&amp; $partition_type eq "-spp" &amp;&amp; !$specify_commandline</code>
					</precond>
					<format>		
						<language>perl</language> 
						<code> "-p partition_file.txt"</code>
					</format>
					<group>2</group>
				</attributes>
			</parameter>		
						
			<parameter ishidden="1" type="String">
				<name>partition_command4</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>defined $partition_type &amp;&amp; $which_iqtree &gt; 200 &amp;&amp; $partition_type eq "-sp" &amp;&amp; !$specify_commandline</code>
					</precond>
					<format>		
						<language>perl</language>
						<code>"-Q partition_file.txt"</code>
					</format>
					<group>2</group>
				</attributes>
			</parameter>			
										
			<parameter ishidden="1" type="String">
				<name>partition_command5</name>
				<attributes>
					<precond>
						<language>perl</language>
						<code>defined $partition_type &amp;&amp; $which_iqtree &gt; 200 &amp;&amp; $partition_type eq "-q" &amp;&amp; !$specify_commandline</code>
					</precond>
					<format>		
						<language>perl</language>
						<code>"-q partition_file.txt"</code>
					</format>
					<group>2</group>
				</attributes>
			</parameter>		
			
<!-- Yes! You can specify this via a NEXUS partition file. In fact, you can mix any data types supported in IQ-TREE,
 including also codon, binary and morphological data. To do so, each data type should be stored in a separate 
 alignment file (see also Partitioned analysis with mixed data). As an example, assuming dna.phy is a DNA alignment
 and and prot.phy is a protein alignment. Then a partition file mixing two types of data can be specified as follows:
 #nexus
begin sets;
    charset part1 = dna.phy: 1-100 201-300;
    charset part2 = dna.phy: 101-200;
    charset part3 = prot.phy: 1-150;
    charset part4 = prot.phy: 151-400;
    charpartition mine = HKY:part1, GTR+G:part2, WAG+I+G:part3, LG+G:part4;
end;
 -->
<!-- Step 1, identify that multiple input files are present -->
			
<parameter  type="Switch"> 
	<name>mixed_sequence</name>
		<attributes>
			<prompt>I want to use multiple alignment files for a partitioned analysis</prompt>
			<precond>
				<language>perl</language>
				<code>$nexus_partition_file</code>
			</precond>
			<vdef>
				<value>0</value>
			</vdef>
		</attributes>
	</parameter>
	
	<parameter  type="Excl"> 
	<name>num_mixedsequences</name>
		<attributes>
			<prompt>How many alignment files in your partitioned analysis</prompt>
			<precond>
				<language>perl</language>
				<code>$mixed_sequence</code>
			</precond>
			<vlist>
				<value>2</value>
				<label>2</label>
				<value>3</value>
				<label>3</label>
				<value>4</value>
				<label>4</label>
				<value>5</value>
				<label>5</label>
			</vlist>
		</attributes>
	</parameter>
	
	<parameter  type="InFile"> 
	<name>datatype2_file</name>
		<attributes>
			<prompt>Select the second alignment file (alignment2.phy)</prompt>
			<precond>
				<language>perl</language>
				<code>$num_mixedsequences &gt; 1 </code>
			</precond>
			<filenames>alignment2.phy</filenames>
					<warns>
						<warn>
							<message>Your second alignment file will be named alignment2.phy, use this name to call the file from your nexus partition file</message>
							<language>perl</language>
						  <code>defined $datatype2_file &amp;&amp; $specify_commandline</code>
						</warn>
					</warns>
		</attributes>
	</parameter>
	
	<parameter type="InFile"> 
	<name>datatype3_file</name>
		<attributes>
			<prompt>Select the file with your third datatype (alignment3.phy)</prompt>
			<precond>
				<language>perl</language>
				<code>$num_mixedsequences &gt; 2 </code>
			</precond>
			<filenames>alignment3.phy</filenames>
				<warns>
						<warn>
							<message>Your third alignment file will be named alignment3.phy, use this name to call the file from your nexus partition file</message>
							<language>perl</language>
						  <code>defined $datatype3_file &amp;&amp; $specify_commandline</code>
						</warn>
					</warns>
		</attributes>
	</parameter>
	
	<parameter type="InFile"> 
	<name>datatype4_file</name>
		<attributes>
			<prompt>Select the file with your fourth datatype (alignment4.phy)</prompt>
			<precond>
				<language>perl</language>
				<code>$num_mixedsequences &gt; 3 </code>
			</precond>
			<filenames>alignment4.phy</filenames>
					<warns>
						<warn>
							<message>Your fourth alignment file will be named alignment4.phy, use this name to call the file from your nexus partition file</message>
							<language>perl</language>
						  <code>defined $datatype4_file &amp;&amp; $specify_commandline</code>
						</warn>
					</warns>
		</attributes>
	</parameter>
	
	<parameter type="InFile"> 
	<name>datatype5_file</name>
		<attributes>
			<prompt>Select the file with your fifth datatype (alignment5.phy)</prompt>
			<precond>
				<language>perl</language>
				<code>$num_mixedsequences &gt; 4 </code>
			</precond>
			<filenames>alignment5.phy</filenames>
				<warns>
						<warn>
							<message>Your fifth alignment file will be named alignment5.phy, use this name to call the file from your nexus partition file</message>
							<language>perl</language>
						  <code>defined $datatype5_file &amp;&amp; $specify_commandline</code>
						</warn>
					</warns>
		</attributes>
	</parameter>
	
	</parameters>
	</paragraph>
</parameter>


<!-- automatic model selection  -->	
<parameter type="Paragraph">
	<paragraph>
		<name>model_selection</name>
		<prompt>Automatic Model Selection</prompt>
		<parameters>
<!-- Automatic model selection
The default model (e.g., HKY+F for DNA, LG for protein data) may not fit well to the data. Therefore, IQ-TREE allows to automatically determine the best-fit model via a series of -m TEST... option:
Usage and meaning
-m TESTONLY Perform standard model selection like jModelTest (for DNA) and ProtTest (for protein). Moreover, IQ-TREE also works for codon, binary and morphogical data. 
-m TEST Like -m TESTONLY but immediately followed by tree reconstruction using the best-fit model found. So this performs both model selection and tree inference within a single run. 
-m TESTNEWONLY or -m MF Perform an extended model selection that additionally includes FreeRate model compared with -m TESTONLY. Recommended as replacement for -m TESTONLY. Note that LG4X is a FreeRate model, but by default is not included because it is also a protein mixture model. To include it, use -madd option (see table below). 
-m TESTNEW or -m MFP Like -m MF but immediately followed by tree reconstruction using the best-fit model found. 
-m TESTMERGEONLY Select best-fit partitioning scheme like PartitionFinder. 
-m TESTMERGE Like -m TESTMERGEONLY but immediately followed by tree reconstruction using the best partitioning scheme found. 
-m TESTNEWMERGEONLY or -m MF+MERGE Like -m TESTMERGEONLY but additionally includes FreeRate model. 
-m TESTNEWMERGE or -m MFP+MERGE Like -m MF+MERGE but immediately followed by tree reconstruction using the best partitioning scheme found. 
  -->
			
			<parameter  issimple="0" type="Excl"> 
				<name>specify_model</name>
				<attributes>
					<prompt>Test for the best model (-m TEST)</prompt>
					<precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<vlist>
						<value>TESTONLY</value> 
						<label>TESTONLY</label>
						<value>TEST</value>
						<label>TEST</label>
						<value>TESTNEWONLY</value>
						<label>TESTNEWONLY</label>
						<value>TESTNEW</value>
						<label>TESTNEW</label>
						<value>TESTMERGEONLY</value>
						<label>TESTMERGEONLY</label>
						<value>TESTMERGE</value>
						<label>TESTMERGE</label>
						<value>TESTNEWMERGEONLY</value>
						<label>TESTNEWMERGEONLY</label>
						<value>TESTNEWMERGE</value>
						<label>TESTNEWMERGE</label>
					</vlist>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-m $value$specify_liemarkov":""</code>
					</format>
					<group>4</group>
					<comment>
<value>The default model (e.g.,HKY+Ffor DNA,LGfor protein data) may not fit well to thedata. Therefore, IQ-TREE allows to automatically determine the best-fit model via a series of-m TEST...options:</value>
<value></value>
					</comment>
				</attributes>
			</parameter>

<!-- +LM Additionally consider all Lie Markov models
     +LMRYAdditionally consider all Lie Markov models with RY symmetry
     +LMWSAdditionally consider all Lie Markov models with WS symmetry
     +LMMKAdditionally consider all Lie Markov models with MK symmetry
     +LMSSAdditionally consider all strand-symmetric Lie Markov models -->
<!-- Lie markov options -->
 			<parameter  type="Excl"> 
				<name>specify_liemarkov</name>
				<attributes>
					<prompt>Specify a Lie Markov Option</prompt>
					<precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<vlist>
						<value>+LM</value>
						<label>Consider all Lie Markov models</label>
						<value>+LMRY</value>
						<label>Consider all Lie Markov models with RY symmetry</label>
						<value>+LMWS</value>
						<label>Consider all Lie Markov models with WS symmetry</label>
						<value>+LMMK</value>
						<label>Consider all Lie Markov models with MK symmetry</label>
						<value>+LMSS</value>
						<label>Consider all strand-symmetric Lie Markov models</label>
					</vlist>
				</attributes>
			</parameter>
			
<!-- -rcluster Specify the percentage for the relaxed clustering algorithm (Lanfear et al., 2014). This is similar to -*rcluster-percent option of PartitionFinder. For example, with -rcluster 10 only the 
top 10% partition schemes are considered to save computations.  -->	
			<parameter type="Excl"> 
				<name>select_rcluster</name>
				<attributes>
					<prompt>Specify the relaxed clustering algorithm to use (-rcluster)</prompt>
					<precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
						<vlist>
							<value>-rcluster</value>
							<label>rcluster</label>
							<value>-rclusterf</value>
							<label>rclusterf</label>
							<value>-rcluster-max</value>
							<label>specify max partition pairs</label>
						</vlist>
						<comment>
<value>Use this option to specify the percentage for the relaxed clustering algorithm (Lanfear et al., 2014). This is similar to -*rcluster-percent option of PartitionFinder. For example, with -rcluster 10 only the 
top 10% partition schemes are considered to save computations.</value>
						</comment>
				</attributes>
			</parameter>
			
<!-- -rcluster Specify the percentage for the relaxed clustering algorithm (Lanfear et al., 2014). This is similar to -*rcluster-percent option of PartitionFinder. For example, with -rcluster 10 only the 
top 10% partition schemes are considered to save computations.  -->	
			<parameter  issimple="0" type="Integer"> 
				<name>specify_rclusterval</name>
				<attributes>
					<prompt>Specify the percentage or max partition pairs for relaxed clustering algorithm</prompt>
					<precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ? "$select_rcluster $value":""</code>
					</format>
					<group>4</group>
					<ctrls>
						<ctrl>
							<message>Please specify the rcluster algorithm</message>
							<language>perl</language>
							<code>defined $specify_rclusterval &amp;&amp; !defined $select_rcluster</code>
						</ctrl>
						<ctrl>
							<message>Please specify the percentage or max partition pairs for the rcluster algorithm</message>
							<language>perl</language>
							<code>!defined $specify_rclusterval &amp;&amp; defined $select_rcluster</code>
						</ctrl>
					</ctrls>
					<comment>
<value>Use this option to specify the percentage for the relaxed clustering algorithm (Lanfear et al., 2014). This is similar to -*rcluster-percent option of PartitionFinder. For example, with -rcluster 10 only the 
top 10% partition schemes are considered to save computations.</value>
					</comment>
				</attributes>
			</parameter>
	
<!-- -mset Specify the name of a program (raxml, phyml or mrbayes) to restrict to only those models supported by the specified program. Alternatively, one can specify a comma-separated list of base models. 
For example, -mset WAG,LG,JTT will restrict model selection to WAG, LG, and JTT instead of all 18 AA models to save computations.  -->	
			<parameter  issimple="0" type="String"> 
				<name>specify_basemodels</name>
				<attributes>
					<prompt>Specify names of the base models or program (-mset)</prompt>
					<precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-mset $value":""</code>
					</format>
					<group>4</group>
					<comment>
						<value>For -mset, specify the name of a program (raxml, phyml or mrbayes) to restrict to 
					only those models supported by the specified program. Alternatively, one can specify a 
					comma-separated list of base models. For example, -mset WAG,LG,JTT will restrict model 
					selection to WAG, LG, and JTT instead of all 18 AA models to save computations.
						</value>
					</comment>
				</attributes>
			</parameter>
	
<!-- -msub Specify either nuclear, mitochondrial, chloroplast or viral to restrict to those AA models designed for specified source.   -->	
			<parameter  issimple="0" type="Excl"> 
				<name>specify_aamodels</name>
				<attributes>
					<prompt>Specify nuclear, mitochondrial, chloroplast or viral (-msub, protein)</prompt>
					<precond>
						<language>perl</language>
						<code>$datatype eq "PROTEIN" &amp;&amp; !$specify_commandline</code>
					</precond>
					<vlist>
						<value>nuclear</value>
						<label>Nuclear</label>
						<value>mitochondrial</value>
						<label>Mitochondrial</label>
						<value>chloroplast</value>
						<label>Chloroplast</label>
						<value>viral</value>
						<label>Viral</label>
					</vlist>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-msub $value":""</code>
					</format>
					<group>4</group>
				</attributes>
			</parameter>
	
<!-- -mfreq Specify a comma-separated list of frequency types for model selection. DEFAULT: -mfreq FU,F for protein models (FU = AA frequencies given by the protein matrix, F = empirical AA frequencies
 from the data), -mfreq ,F1x4,F3x4,F for codon models   -->	
			<parameter  issimple="0" type="String"> 
				<name>specify_freqtypes</name>
				<attributes>
					<prompt>Specify a comma-separated list of frequency types for model selection (-mfreq)</prompt>
				    <precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-mfreq $value":""</code>
					</format>
					<group>4</group>
				</attributes>
			</parameter>
	
<!-- -mrate Specify a comma-separated list of rate heterogeneity types for model selection. DEFAULT: -mrate E,I,G,I+G for standard procedure, -mrate E,I,G,I+G,R for new selection procedure    -->	
			<parameter  issimple="0" type="String"> 
				<name>specify_ratehettypes</name>
				<attributes>
					<prompt>Specify a comma-separated list of rate heterogeneity types for model selection (-mrate)</prompt>
				    <precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-mrate $value":""</code>
					</format>
					<group>4</group>
				</attributes>
			</parameter>
	
<!-- -cmin Specify minimum number of categories for FreeRate model. DEFAULT: 2     -->	
			<parameter  issimple="0" type="Integer"> 
				<name>specify_mincat</name>
				<attributes>
					<prompt>Specify minimum number of categories for FreeRate model (-cmin)</prompt>
				    <precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-cmin $value":""</code>
					</format>
					<group>4</group>
				</attributes>
			</parameter>
	
<!-- -cmax Specify maximum number of categories for FreeRate model. It is recommended to increase if alignment is long enough. DEFAULT: 10     -->	
			<parameter  issimple="0" type="Integer"> 
			<name>specify_maxcat</name>
				<attributes>
				    <precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<prompt>Specify maximum number of categories for FreeRate model (-cmax)</prompt>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-cmax $value":""</code>
					</format>
					<group>4</group>
				</attributes>
			</parameter>
	
<!-- Specify either AIC, AICc or BIC for the optimality criterion to apply for new procedure. DEFAULT: all three criteria are considered    -->	
			<parameter  issimple="0" type="String"> 
			<name>specify_merit</name>
				<attributes>
					<prompt>Specify either AIC, AICc or BIC for the optimality criterion (-merit)</prompt>
				    <precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-merit $value":""</code>
					</format>
					<group>4</group>
				</attributes>
			</parameter>
	
<!-- Turn on full tree search for each model considered, to obtain more accurate result. Only recommended if enough computational resources are available. DEFAULT: fixed starting tree   -->	
			<parameter  issimple="0" type="Switch"> 
			<name>specify_fulltreesearch</name>
				<attributes>
					<prompt>Turn on full tree search for each model considered, to obtain more accurate result. (-mtree)</prompt>
				    <precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<format>
						<language>perl</language>
						<code>($value) ? "-mtree":""</code>
					</format>
					<group>4</group>
				</attributes>
			</parameter>
	
<!-- -madd Specify a comma-separated list of mixture models to additionally consider for model selection. For example, -madd LG4M,LG4X to additionally include these two protein mixture models.    -->	
			<parameter  issimple="0" type="String"> 
			<name>specify_addlmodels</name>
				<attributes>
					<prompt>Specify a comma-separated list of mixture models to additionally consider for model selection. (-madd)</prompt>
				    <precond>
						<language>perl</language>
						<code>!$specify_commandline</code>
					</precond>
					<format>
						<language>perl</language>
						<code>(defined $value) ?  "-madd $value":""</code>
					</format>
					<group>4</group>
				</attributes>
			</parameter>

<!-- -mdef Specify a NEXUS model file to define new models. -->
		<parameter  issimple="0" type="InFile"> 
			<name>specify_nexusmodelfile</name>
				<attributes>
					<prompt>Specify a Nexus Model file. (-mdef)</prompt>
					<filenames>modelfile.nex</filenames>
					<group>4</group>
					<warns>
						<warn>
							<message>Your Nexus model file will be named modelfile.nex, use this name in your command line to access the nexus model file</message>
							<language>perl</language>
						  <code>defined $specify_nexusmodelfile &amp;&amp; $specify_commandline</code>
						</warn>
					</warns>
				</attributes>
			</parameter>
			
		<parameter  ishidden="1" type="String"> 
			<name>specify_nexusmodelfile2</name>
				<attributes>
				    <precond>
						<language>perl</language>
						<code>defined $specify_nexusmodelfile &amp;&amp; !$specify_commandline</code>
					</precond>
					<format>
						<language>perl</language>
						<code>"-mdef modelfile.nex"</code>
					</format>
					<group>4</group>
				</attributes>
			</parameter>

		</parameters>
	</paragraph>
</parameter>  

<!-- Specifying substitution models -->
<parameter type="Paragraph">
	<paragraph>
		<name>specify_subst</name>
		<prompt>Specify Substitution Models</prompt>
			<parameters>
							
			<parameter  issimple="0" type="String"> 
					<name>freetextmodel</name>
					<attributes>
						<prompt>Specify any model using free text (-m)</prompt>
				    <precond>
						<language>perl</language>
						<code> !$specify_commandline</code>
					</precond>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a DNA model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextmodel &amp;&amp; defined $specify_dnamodel</code>
							</ctrl>
						</ctrls>
						<group>4</group>
				</attributes>
			</parameter>
			
			<parameter ishidden= "1" type="String">
					<name>dnamodel_string</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$datatype eq "DNA" &amp;&amp; !$specify_commandline </code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $specify_dnamodel) ? "-m $specify_dnamodel$specify_modelfreq$specify_modelrate$asc_bias":""</code>
					</format>
					<group>4</group>
					</attributes>
				</parameter>
				
				<parameter ishidden= "1" type="String">
					<name>model_string2</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>!$specify_commandline </code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $freetextmodel) ? "-m $freetextmodel":""</code>
					</format>
					<group>4</group>
					</attributes>
				</parameter>
				
				<parameter  issimple="0" type="Excl"> 
					<name>specify_dnamodel</name>
					<attributes>
						<prompt>Specify a DNA model (-m )</prompt>
						<precond>
							<language>perl</language>
							<code>$datatype eq "DNA" &amp;&amp; !$specify_commandline</code>
						</precond>
						<vlist>
							<value>JC69</value>
							<label>JC/JC69</label>
							<value>F81</value>
							<label>F81</label>
							<value>K80</value>
							<label>K2P/K80</label>
							<value>HKY</value>
							<label>HKY/HKY85</label>
							<value>TN93</value>
							<label>TN/TrN/TN93</label>
							<value>TNe</value>
							<label>TNe</label>
							<value>K81</value>
							<label>K3P/K81</label>
							<value>K81u</value>
							<label>K81u</label>
							<value>TPM2</value>
							<label>TPM2</label>
							<value>TPM2u</value>
							<label>TPM2u</label>
							<value>TPM3</value>
							<label>TPM3</label>
							<value>TPM3u</value>
							<label>TPM3u</label>
							<value>TIM</value>
							<label>TIM</label>
							<value>TIMe</value>
							<label>TIMe</label>
							<value>TIM2</value>
							<label>TIM2</label>
							<value>TIM2e</value>
							<label>TIM2e</label>
							<value>TIM3</value>
							<label>TIM3</label>
							<value>TIM3e</value>
							<label>TIM3e</label>
							<value>TVM</value>
							<label>TVM</label>
							<value>TVMe</value>
							<label>TVMe</label>
							<value>SYM</value>
							<label>SYM</label>
							<value>GTR</value>
							<label>GTR</label>
						</vlist>
						<group>4</group>
	<!-- 				<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a DNA model and run a model test </message>
								<language>perl</language>
								<code>defined $specify_model &amp;&amp; defined $value &amp;&amp; !$specify_commandline </code>
							</ctrl>
						</ctrls> -->	
                    </attributes>
                </parameter>

				<parameter ishidden= "1" type="String">
					<name>aamodel_string</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$datatype eq "PROTEIN"  &amp;&amp; !$specify_commandline </code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $specify_protmodel) ? "-m $specify_protmodel$specify_modelfreq$specify_modelrate":""</code>
					</format>
					<group>4</group>
					</attributes>
				</parameter>
				
<!-- 			<parameter ishidden= "1" type="String">
					<name>aamodel_string2</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$datatype eq "PROTEIN" &amp;&amp; $specify_runtype == 2 &amp;&amp; defined $freetextprotmodel</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $freetextprotmodel) ? "-m $freetextprotmodel":""</code>
					</format>
					</attributes>
				</parameter>  -->
					
				<parameter  issimple="0" type="Excl"> 
					<name>specify_protmodel</name>
					<attributes>
						<prompt>Specify a Protein model (-m )</prompt>
						<precond>
							<language>perl</language>
							<code>($datatype eq "PROTEIN" || $datatype eq "NT2AA") &amp;&amp; !$specify_commandline</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>FLU</value>
							<label>FLU</label>
							<value>HIVb</value>
							<label>HIVb</label>
							<value>HIVw</value>
							<label>HIVw</label>
							<value>JTT</value>
							<label>JTT</label>
							<value>JTTDCMut</value>
							<label>JTTDCMut</label>
							<value>LG</value>
							<label>LG</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>mtMet</value>
							<label>mtMet</label>
							<value>mtVer</value>
							<label>mtVer</label>
							<value>mtInv</value>
							<label>mtInv</label>
							<value>Poisson</value>
							<label>Poisson</label>
							<value>PMB</value>
							<label>PMB</label>
							<value>rtREV</value>
							<label>rtREV</label>
							<value>VT</value>
							<label>VT</label>
							<value>WAG</value>
							<label>WAG</label>
							<value>EAL</value>
							<label>EAL</label>
							<value>ELM</value>
							<label>ELM</label>
							<value>Q.LG</value>
							<label>Q.LG</label>
							<value>Q.pfam</value>	
							<label>Q.pfam</label>
							<value>Q.pfam_gb</value>
							<label>Q.pfam_gb</label>
							<value>Q.bird</value>
							<label>Q.bird</label>
							<value>Q.mammal</value>
							<label>Q.mammal</label>
							<value>Q.insect</value>
							<label>Q.insect</label>
							<value>Q.plant</value>
							<label>Q.plant</label>
							<value>Q.yeast</value>	
							<label>Q.yeast</label>
						</vlist>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a protein model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextmodel &amp;&amp; defined $specify_protmodel &amp;&amp; !$specify_commandline</code>
							</ctrl>
						</ctrls>
						<group>3</group>
				</attributes>
			</parameter>

				<parameter  issimple="0" type="Excl"> 
					<name>specify_protmixture</name>
					<attributes>
						<prompt>Specify a Protein Profile mixture</prompt>
						<precond>
							<language>perl</language>
							<code>($datatype eq "PROTEIN" || $datatype eq "NT2AA") &amp;&amp; defined $specify_protmodel &amp;&amp; !$specify_commandline</code>
						</precond>
						<vlist>
							<value>+C10</value>
							<label>C10</label>
							<value>+C20</value>
							<label>C20</label>
							<value>+C30</value>
							<label>C30</label>
							<value>+C40</value>
							<label>C40</label>
							<value>+C50</value>
							<label>C50</label>
							<value>+C60</value>
							<label>C60</label>
							<value>+EX2</value>
							<label>EX2</label>
							<value>+EX3</value>
							<label>EX3</label>
							<value>+EHO</value>
							<label>EHO</label>
							<value>+UL2</value>
							<label>UL2</label>
							<value>+UL3</value>
							<label>UL3</label>
							<value>+EX_EHO</value>
							<label>EX_EHO</label>
							<value>+LG4M</value>
							<label>LG4M</label>
							<value>+LG4X</value>
							<label>LG4X</label>
							<value>+CF4</value>
							<label>CF4</label>
						</vlist>
						<group>3</group>
				</attributes>
			</parameter>		
			
<!-- 	specify a guide tree -->
	<parameter  type="InFile"> 
	<name>guide_tree</name>
		<attributes>
			<prompt>Specify a guide tree file for PMSF analysis (-ft)</prompt>
			<filenames>guidetree.tre</filenames>
			<precond>
					<language>perl</language>
					<code>($specify_protmodel eq "C10" || $specify_protmodel eq "C20" || $specify_protmodel eq "C30" || $specify_protmodel eq "C40" || $specify_protmodel eq "C50" || $specify_protmodel eq "C60")</code>
			</precond>
			<warns>
				<warn>
					<message>Note that your quidetree file will be named guidetree.tre; your command line must include -ft guidetree.tre</message>
					<language>perl</language>
					<code> defined $guide_tree &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
			<group>4</group>
		</attributes>
	</parameter>
	
<parameter  ishidden="1" type="String"> 
	<name>guide_tree2</name>
		<attributes>
			<precond>
					<language>perl</language>
					<code>($specify_protmodel eq "C10" || $specify_protmodel eq "C20" || $specify_protmodel eq "C30" || $specify_protmodel eq "C40" || $specify_protmodel eq "C50" || $specify_protmodel eq "C60") &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>"-ft guidetree.tre"</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>
	
<!-- specify a frequency file  -->
	<parameter  type="InFile"> 
	<name>frequency_file</name>
		<attributes>
			<prompt>Specify a frequency file for PMSF analysis (-fs)</prompt>
			<filenames>sitefreq.file</filenames>
			<precond>
					<language>perl</language>
					<code>($specify_protmodel eq "C10" || $specify_protmodel eq "C20" || $specify_protmodel eq "C30" || $specify_protmodel eq "C40" || $specify_protmodel eq "C50" || $specify_protmodel eq "C60")</code>
			</precond>
			<group>4</group>
			<warns>
				<warn>
					<message>Note that your sitefreq file will be named sitefreq.file; your command line must include -fs sitefreq.file</message>
					<language>perl</language>
					<code> defined $frequency_file &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
		</attributes>
	</parameter>
	
<parameter  ishidden="1" type="String"> 
	<name>frequency_file2</name>
		<attributes>
			<precond>
					<language>perl</language>
					<code>($specify_protmodel eq "C10" || $specify_protmodel eq "C20" || $specify_protmodel eq "C30" || $specify_protmodel eq "C40" || $specify_protmodel eq "C50" || $specify_protmodel eq "C60") &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code> "-fs sitefreq.file"</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>
	
<!-- -fmax Switch to posterior maximum mode for obtaining site-specific profiles.Default: posterior mean. -->
	<parameter  type="Switch"> 
	<name>max_posteriormode</name>
		<attributes>
			<prompt>Switch to posterior maximum mode for obtaining site-specific profiles (-fmax)</prompt>
			<precond>
					<language>perl</language>
					<code>($specify_protmodel eq "C10" || $specify_protmodel eq "C20" || $specify_protmodel eq "C30" || $specify_protmodel eq "C40" || $specify_protmodel eq "C50" || $specify_protmodel eq "C60") &amp;&amp; !$specify_commandline</code>
			</precond>
			<format>
				<language>perl</language>
				<code>$max_posteriormode ? "-fmax":""</code>
			</format>
			<group>4</group>
		</attributes>
	</parameter>
					
				<parameter ishidden= "1" type="String">
					<name>binmodel_string</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$datatype eq "BIN" &amp;&amp; !$specify_commandline</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $specify_binmodel) ? "-m $specify_binmodel$specify_modelfreq$specify_modelrate":""</code>
					</format>
					<group>4</group>
					</attributes>
				</parameter>
			
			<parameter  issimple="0" type="Excl"> 
					<name>specify_binmodel</name>
					<attributes>
						<prompt>Specify a Binary/Morphological model (-m )</prompt>
						<precond>
							<language>perl</language>
							<code>($datatype eq "BIN" || $datatype eq "MORPH") &amp;&amp; !$specify_commandline</code>
						</precond>
<!-- JC2 Jukes-Cantor type model for binary data. GTR2 General time reversible model for binary data. 
MK Jukes-Cantor type model for morphological data. ORDERED Allowing exchange of neighboring states only. 
MK (default), ORDERED, GTR-->
						<vlist>
							<value>JC2</value>
							<label>JC2</label>
							<value>GTR2</value>
							<label>GTR2</label>
							<value>MK</value>
							<label>MK</label>
							<value>ORDERED</value>
							<label>Ordered</label>
						</vlist>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a BIN model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextmodel &amp;&amp; defined $specify_binmodel</code>
							</ctrl>
							<ctrl>
								<message>Sorry, you cant specify use a MK or Ordered for BIN data</message>
								<language>perl</language>
								<code>$datatype eq "BIN" &amp;&amp; ($specify_binmodel eq "MK" || $specify_binmodel eq "ORDERED")</code>
							</ctrl>
							<ctrl>
								<message>Sorry, you cant specify use a JC2 or GTR2 for morpohological data</message>
								<language>perl</language>
								<code>$datatype eq "MORPH" &amp;&amp; ($specify_binmodel eq "JC2" || $specify_binmodel eq "GTR2")</code>
							</ctrl>
						</ctrls>
						<group>4</group>
				</attributes>
			</parameter>
													
			<parameter ishidden= "1" type="String">
					<name>codonmodel_string</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$datatype eq "CODON" &amp;&amp; !$specify_commandline</code>
						</precond>
					<format>
						<language>perl</language>
						<code>(defined $specify_codonmodel) ? "-m $specify_codonmodel$specify_modelfreq$specify_modelrate":""</code>
					</format>
					<group>4</group>
					</attributes>
				</parameter>
			
				<parameter  issimple="0" type="Excl"> 
					<name>specify_codonmodel</name>
					<attributes>
						<prompt>Specify a Codon model (-m )</prompt>
						<precond>
							<language>perl</language>
							<code>$datatype eq "CODON" &amp;&amp; !$specify_commandline</code>
						</precond>
						<vlist>
							<value>MG</value>
							<label>MG</label>
							<value>MGK</value>
							<label>MGK</label>
							<value>MG1KTS</value>
							<label>MG1KTS</label>
							<value>MG1KTV</value>
							<label>MG1KTV</label>
							<value>MG2K</value>
							<label>MG2K</label>
							<value>GY</value>
							<label>GY</label>
							<value>GY0K</value>
							<label>GY0K</label>
							<value>GY1KTS</value>
							<label>GY1KTS</label>
							<value>GY1KTV</value>
							<label>GY1KTV</label>
							<value>GY2K</value>
							<label>GY2K</label>
							<value>KOSI07</value>
							<label>ECMK07/KOSI07</label>
							<value>ECMrest</value>
							<label>ECMrest</label>
							<value>SCHN05</value>
							<label>ECMS05/SCHN05</label>
						</vlist>
						<vdef>
							<value>GY</value>
						</vdef>
						<ctrls>
							<ctrl>
								<message>Sorry, you cant specify a CODON model and use the free text entry</message>
								<language>perl</language>
								<code>defined $freetextmodel &amp;&amp; defined $specify_codonmodel</code>
							</ctrl>
						</ctrls>
				</attributes>
			</parameter>
			
<!-- +F Empirical state frequency observed from the data. 
+FO State frequency optimized by maximum-likelihood from the data. Note that this is with letter-O and not digit-0. 
+FQ Equal state frequency. 
+F1x4 See Codon frequencies. 
+F3x4 See Codon frequencies. 
 -->
 				<parameter  issimple="0" type="Excl"> 
					<name>specify_modelfreq</name>
					<attributes>
						<prompt>Specify model frequency</prompt>
<!-- JC2 Jukes-Cantor type model for binary data. GTR2 General time reversible model for binary data. 
MK Jukes-Cantor type model for morphological data. ORDERED Allowing exchange of neighboring states only. -->
						<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<vlist>
							<value>+F</value>
							<label>Empirical state frequency</label>
							<value>+FO</value>
							<label>State frequency optimized by maximum-likelihood</label>
							<value>+FQ</value>
							<label>Equal state frequency</label>
							<value>+F1x4</value>
							<label>+F1x4 (codon data)</label>
							<value>+F3x4</value>
							<label>+F3x4 (codon data)</label>
						</vlist>
				</attributes>
			</parameter>
			
<!-- -mwoptTurn on optimizing weights of mixture models. Note that for modelslikeLG+C20+F+Gthis mode is automatically turned on, but not forLG+C20+G. -->
 <parameter  issimple="0" type="Switch"> 
					<name>optimize_weights</name>
					<attributes>
						<prompt>Turn on optimizing weights of mixture models (-mwopt)</prompt>
<!-- JC2 Jukes-Cantor type model for binary data. GTR2 General time reversible model for binary data. 
MK Jukes-Cantor type model for morphological data. ORDERED Allowing exchange of neighboring states only. -->
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>$value ? "-mwopt":""</code>
						</format>
						<group>4</group>
				</attributes>
			</parameter>


<!-- +I Allowing for a proportion of invariable sites. 
+G Discrete Gamma model (Yang, 1994) with default 4 rate categories. The number of categories can be changed with e.g. +G8. 
+I+G Invariable site plus discrete Gamma model (Gu et al., 1995). 
+R FreeRate model (Yang, 1995; Soubrier et al., 2012) that generalizes +G by relaxing the assumption of Gamma-distributed rates. The number of categories can be specified with e.g. +R6. DEFAULT: 4 categories 
+I+R invariable site plus FreeRate model. 
 -->
			 <parameter  issimple="0" type="Excl"> 
					<name>specify_modelrate</name>
					<attributes>
						<prompt>Specify rate heterogeneity</prompt>
						<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
<!-- JC2 Jukes-Cantor type model for binary data. GTR2 General time reversible model for binary data. 
MK Jukes-Cantor type model for morphological data. ORDERED Allowing exchange of neighboring states only. -->
	<!--					<precond>
							<language>perl</language>
							<code>$specify_runtype == 2</code>
						</precond>-->
						<vlist>
							<value>+I</value>
							<label>Invariable sites</label>
							<value>+G</value>
							<label>Discrete Gamma model</label>
							<value>+I+G</value>
							<label>Invariable site plus discrete Gamma model</label>
							<value>+R</value>
							<label>FreeRate model</label>
							<value>+I+R</value>
							<label>Invariable site plus FreeRate model</label>
						</vlist>
				</attributes>
			</parameter>

			
<!-- Optionally, one can specify Ascertainment bias correction by appending +ASC to the model string. Advanced mixture models can also be specified via MIX{...} and FMIX{...} syntax. Option -mwopt can be used to turn on optimizing weights of mixture models.
 -->
					<parameter issimple="1" type="Excl">
					<name>asc_bias</name>
						<attributes>
							<prompt>Correct for Ascertainment bias (+ASC)</prompt>
							<precond>
								<language>perl</language>
								<code>!$specify_commandline</code>
							</precond>
							<vlist>
								<value>+ASC</value>
								<label>yes</label>
								<value></value>
								<label>no</label>
							</vlist>
							<vdef>
								<value></value>
							</vdef>
							<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 constant sites.</value>
							</comment>
						</attributes>
					</parameter>
			
<!-- -a Specify the Gamma shape parameter -->
				<parameter type="Float">
					<name>gamma_shape</name>
					<attributes>
						<prompt>Specify the Gamma shape parameter (-a)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-a $value":""</code>
						</format>
						<group>4</group>
						<ctrls>
							<ctrl>
								<message>The gamma shape parameter must be greater than 0</message>
								<language>perl</language>
								<code>defined $gamma_shape &amp;&amp; $gamma_shape &lt;= 0</code>
							</ctrl>
						</ctrls>
<!--  						<comment>
						<value>
Specify number of initial parsimony trees. DEFAULT: 100. Here the PLL library (Flouri et al., 2015) is used, which implements the randomized stepwise addition and parsimony subtree pruning and regafting (SPR).
						</value>
						</comment> -->
					</attributes>
				</parameter>
				
<!--  -gmedian Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994) -->
				<parameter type="Switch">
					<name>median_approximation</name>
					<attributes>
						<prompt>Perform the median approximation for Gamma rate heterogeneity (-gmedian)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-gmedian":""</code>
						</format>
						<group>4</group>
  						<comment>
						<value>
Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994)
						</value>
						</comment> 
					</attributes>
				</parameter>
				
<!-- -i Specify the proportion of invariable sites (default: estimate) -->
				<parameter type="Float">
					<name>invariable_sites</name>
					<attributes>
						<prompt>Specify the proportion of invariable sites (-i)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-i $value":""</code>
						</format>
						<group>4</group>
<!--   					<comment>
						<value>
Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994)
						</value>
						</comment> --> 
					</attributes>
				</parameter>
				
<!-- -*pt-gamma-inv Perform more thorough estimation for +I+G model parameters -->
				<parameter type="Switch">
					<name>thorough_estimation</name>
					<attributes>
						<prompt>Perform more thorough estimation for +I+G model parameters (--opt-gamma-inv)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "--opt-gamma-inv":""</code>
						</format>
						<group>4</group>
<!--   					<comment>
						<value>
Perform the median approximation for Gamma rate heterogeneity instead of the default mean approximation (Yang, 1994)
						</value>
						</comment> --> 
					</attributes>
				</parameter>
			
			</parameters>
	</paragraph>
</parameter>

<parameter type="Paragraph">
	<paragraph>
		<name>tree_search_params</name>
		<prompt>Tree Search Parameters</prompt>
			<parameters>
			
				<parameter type="Switch">
					<name>slower_NNI</name>
					<attributes>
						<prompt>Turn on more thorough and slower NNI search (-allnni)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-allnni":""</code>
						</format>
						<group>20</group>
						<comment>
						<value>
Turn on more thorough and slower NNI search. It means that IQ-TREE will consider all possible NNIs instead of only those in the vicinity of previously applied NNIs. DEFAULT: OFF
						</value>
						</comment>
					</attributes>
				</parameter>
								
				<parameter type="Switch">
					<name>no_mlpairwise</name>
					<attributes>
						<prompt>Avoid computing ML pairwise distances and BIONJ tree (-djc)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-djc":""</code>
						</format>
						<group>4</group>
						<comment>
						<value>
Avoid computing ML pairwise distances and BIONJ tree.
						</value>
						</comment>
					</attributes>
				</parameter>

<!-- -fastTurn on the fast tree search mode, where IQ-TREE will justconstruct two starting trees: maximum parsimony and BIONJ, 
which are then optimized by nearest neighbor interchange (NNI).Introduced in version 1.6. -->
				<parameter type="Switch">
					<name>use_fasttreesearch</name>
					<attributes>
						<prompt>Turn on the fast tree search mode (-fast)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-fast":""</code>
						</format>
						<group>4</group>
						<comment>
						<value>
Avoid computing ML pairwise distances and BIONJ tree.
						</value>
						</comment>
					</attributes>
				</parameter>
									
				<parameter type="InFile">
					<name>constraint_file</name>
					<attributes>
						<prompt>Specify a topological constraint tree file in NEWICK format (-g)</prompt>
						<filenames>constraintfile.txt</filenames>
						<group>4</group>
						<warns>
				<warn>
					<message>Note that your constraint tree file  will be named constraintfile.txt; your command line must include -g constraintfile.txt</message>
					<language>perl</language>
					<code> defined $constraint_file &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
		<comment>
						<value>
Specify a topological in NEWICK format. The constraint tree can be a multifurcating tree and need not include all taxa.
						</value>

						</comment>
					</attributes>
				</parameter>
			
			<parameter ishidden="1" type="String">
					<name>constraint_file2</name>
					<attributes>
					<precond>
							<language>perl</language>
							<code>defined $constraint_file &amp;&amp; !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code> "-g constraintfile.txt"</code>
						</format>
						<group>4</group>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>num_parstrees</name>
					<attributes>
						<prompt>Specify number of initial parsimony trees (-ninit)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-ninit $value":""</code>
						</format>
						<group>4</group>
						<comment>
						<value>
Specify number of initial parsimony trees. DEFAULT: 100. Here the PLL library (Flouri et al., 2015) is used, which implements the randomized stepwise addition and parsimony subtree pruning and regafting (SPR).
						</value>
						</comment>
					</attributes>
				</parameter>

				<parameter type="Integer">
					<name>num_tostop</name>
					<attributes>
						<prompt>Number of iterations to stop (-n)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-n $value":""</code>
						</format>
						<group>5</group>
						<ctrls>
							<ctrl>
								<message>Sorry, the -n parameter cannot be used with Ultrafast Bootstrapping</message>
								<language>perl</language>
								<code>(defined $value) &amp;&amp; $bootstrap_type eq "bb"</code>
							</ctrl>
						</ctrls>
						<comment>
						<value>
Specify number of iterations to stop. This option overrides -nstop criterion. Use -n 0 to only estimate model parameters on an initial parsimony tree and ignore a full tree search to save time
						</value>
						</comment>
					</attributes>
				</parameter>
								
				<parameter type="Integer">
					<name>num_topparstrees</name>
					<attributes>
						<prompt>Specify number of top initial parsimony trees (-ntop)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-ntop $value":""</code>
						</format>
						<group>7</group>
						<comment>
						<value>
Specify number of top initial parsimony trees to optimize with ML nearest neighbor interchange (NNI) search to initialize the candidate set. DEFAULT: 20
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>num_besttrees</name>
					<attributes>
						<prompt>Number of trees in the candidate set to maintain (-nbest)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-nbest $value":""</code>
						</format>
						<group>6</group>
						<comment>
						<value>
Specify number of trees in the candidate set to maintain during ML tree search. DEFAULT: 5
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>num_unsucctostop</name>
					<attributes>
						<prompt>Number of unsuccessful iterations to stop (-nstop)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-nstop $value":""</code>
						</format>
						<group>8</group>
						<comment>
						<value>
Specify number of unsuccessful iterations to stop. DEFAULT: 100
						</value>
						</comment>
					</attributes>
				</parameter>

				<parameter type="Float">
					<name>perturb_strength</name>
					<attributes>
						<prompt>Perturbation strength (between 0 and 1) (-pers)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-pers $value":""</code>
						</format>
						<group>8</group>
						<comment>
						<value>
Specify perturbation strength (between 0 and 1) for randomized NNI. DEFAULT: 0.5
						</value>
						</comment>
					</attributes>
				</parameter>
												
				<parameter type="Integer">
					<name>specify_radius</name>
					<attributes>
						<prompt>SPR radius for the initial search (-sprrad)</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<group>9</group>
						<vdef>
							<value>6</value>
						</vdef>
						<comment>
						<value>
Specify SPR radius for the initial parsimony tree search. DEFAULT: 6
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter ishidden="1" type="String">
					<name>specify_radiusval20</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$which_iqtree &gt; 19 &amp;&amp; defined $specify_radius</code>
						</precond>
						<format>
							<language>perl</language>
							<code>"--sprrad $specify_radius"</code>
						</format>
						<group>10</group>
					</attributes>
				</parameter>
				
				<parameter ishidden="1"  type="String">
					<name>specify_radiusval16</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$which_iqtree &lt; 19  &amp;&amp; defined $specify_radius</code>
						</precond>
						<format>
							<language>perl</language>
							<code>"-sprrad $specify_radius"</code>
						</format>
						<group>10</group>
					</attributes>
				</parameter>
				
			</parameters>
	</paragraph>
</parameter>

<parameter type="Paragraph">
	<paragraph>
		<name>ultrafast_search_params</name>
		<prompt>Bootstrap Search Parameters</prompt>
			<parameters>
			
				<parameter ismandatory="0" type = "Excl">
					<name>bootstrap_type</name>
					<attributes>
						<prompt>Bootstrap Type</prompt>
					<precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
						<vlist>
  							<value></value>
							<label>No bootstrap</label>
							<value>bb</value>
							<label>Ultrafast</label>
							<value>b</value>
							<label>Non-Parametric (complete,b)</label>
							<value>bo</value>
							<label>Non-Parametric (bo)</label>
							<value>bc</value>
							<label>Non-Parametric (bc)</label>
						</vlist>
						<group>11</group>
<!--						<vdef>
							<value>bb</value>
						</vdef>	-->
					</attributes>				
				</parameter>
				
				<parameter ishidden="1" type = "String">
					<name>bootstrap_typeh1</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$bootstrap_type eq bb &amp;&amp; $which_iqtree &lt; 212 </code>
						</precond>
						<format>
							<language>perl</language>
							<code> "-bb $num_bootreps"</code>
						</format>
						<group>12</group>
					</attributes>				
				</parameter>
				
				<parameter ishidden="1" type = "String">
					<name>bootstrap_typeh2</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$bootstrap_type eq bb &amp;&amp; $which_iqtree &gt; 16</code>
						</precond>
						<format>
							<language>perl</language>
							<code> "-B $num_bootreps"</code>
						</format>
						<group>13</group>
					</attributes>				
				</parameter>
							
				<parameter ishidden="1" type = "String">
					<name>bootstrap_typeh3</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type &amp;&amp; $bootstrap_type ne "bb"</code>
						</precond>
						<format>
							<language>perl</language>
							<code> "-$bootstrap_type  $num_bootreps"</code>
						</format>
						<group>14</group>
					</attributes>				
				</parameter>
				
				<parameter type="Integer">
					<name>num_bootreps</name>
					<attributes>
						<prompt>Specify number of bootstrap replicates (>=1000 for ultrafast)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<ctrls>
							<ctrl>
								<message>Please enter a number of bootstraps</message>
								<language>perl</language>
								<code>defined $bootstrap_type &amp;&amp; !defined $num_bootreps</code>
							</ctrl>
							<ctrl>
								<message>For ultrafast, the value of bootstraps must be greater than or equal to 1,000</message>
								<language>perl</language>
								<code>$bootstrap_type eq "bb" &amp;&amp; $num_bootreps &lt; 1000</code>
							</ctrl>
						</ctrls>
						<comment>
<value>-b: Specify number of bootstrap replicates (recommended >=100; for ultrafast (-bb) >=1000). This will perform both bootstrap and analysis on original alignment and provide a consensus tree. -bc Like -b but omit analysis on original alignment. 
-bo Like -b but only perform bootstrap analysis (no analysis on original alignment and no consensus tree).
						</value>
						</comment>						
					</attributes>
				</parameter>
								
				<parameter type="Integer">
					<name>max_iters</name>
					<attributes>
						<prompt>Specify maximum number of iterations to stop. (-nm)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-nm $value":""</code>
						</format>
						<comment>
						<value>
Specify maximum number of iterations to stop. DEFAULT: 1000
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Integer">
					<name>iter_interval</name>
					<attributes>
						<prompt>Iteration interval checking for UFBoot convergence (-nstep)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-nstep $value":""</code>
						</format>
						<ctrls>
							<ctrl>
								<message>Step size must be a multiple of 2</message>
								<language>perl</language>
								<code>defined $iter_interval &amp;&amp; ((($iter_interval) % 2) != 0)</code>
							</ctrl>
							<ctrl>
								<message>Step size must be at least 10</message>
								<language>perl</language>
								<code>defined $iter_interval &amp;&amp; $iter_interval &lt; 10 </code>
							</ctrl>
						</ctrls>
						<comment>
						<value>
Specify iteration interval checking for UFBoot convergence. DEFAULT: every 100 iterations
						</value>
						</comment>
					</attributes>
				</parameter>
											
				<parameter type="Float">
					<name>cc_ufboot</name>
					<attributes>
						<prompt>Minimum correlation coefficient for UFBoot convergence criterion (-bcor)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-bcor $value":""</code>
						</format>
						<comment>
						<value>
Specify minimum correlation coefficient for UFBoot convergence criterion. DEFAULT: 0.99
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Float">
					<name>specify_tiebreaker</name>
					<attributes>
						<prompt>SPR radius for the initial search (-beps)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value ) ? "-beps $value":""</code>
						</format>
						<comment>
						<value>
Specify a small epsilon to break tie in RELL evaluation for bootstrap trees. DEFAULT: 0.5
						</value>
						</comment>
					</attributes>
				</parameter>
												
				<parameter type = "Switch">
					<name>use_bnni</name>
					<attributes>
						<prompt>Use bnni to reduce overestimating support (-bnni)</prompt>
						<precond>
							<language>perl</language>
							<code>$bootstrap_type eq "bb"</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value) ? "-bnni" : ""</code>
						</format>
						<vdef>
							<value>1</value>
						</vdef>	
					</attributes>				
				</parameter>
								
				<parameter type="Excl">
					<name>part_resample</name>
					<attributes>
						<prompt>Resampling strategies for partitioned analysis (-bspec/-bsam)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $partition_file &amp;&amp; !$specify_commandline</code>
					</precond>
						<vlist>
							<value>GENE</value>
							<label>GENE</label>
							<value>GENESITE</value>
							<label>GENESITE</label>
						</vlist>
						<comment>
						<value>
Specify the resampling strategies for partitioned analysis. By default, IQ-TREE resamples alignment sites within partitions. 
With -bspec GENE IQ-TREE will resample partitions. 
With -bspec GENESITE IQ-TREE will resample partitions and then resample sites within resampled partitions (Gadagkar et al., 2005).
						</value>
						</comment>
					</attributes>
				</parameter>
				
<!-- the flag for this command changed between versions  -->				
				<parameter ishidden="1" type="String">
					<name>part_resample1</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$which_iqtree &lt; 19 &amp;&amp; !$use_bnni &amp;&amp; !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $part_resample) ? "-bspec $part_resample":""</code>
						</format>
					</attributes>
				</parameter>

				<parameter ishidden="1" type="String">
					<name>part_resample2</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$which_iqtree &lt; 19 &amp;&amp; $use_bnni &amp;&amp; !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $part_resample) ? "-bspec $part_resample -keep_empty_seq":""</code>
						</format>
					</attributes>
				</parameter>
				
<!-- the flag for this command changed between versions  -->				
				<parameter ishidden="1" type="String">
					<name>part_resample3</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$which_iqtree &gt; 200  &amp;&amp; !$use_bnni &amp;&amp; !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $part_resample ) ? "-bsam $part_resample":""</code>
						</format>
					</attributes>
				</parameter>

				<parameter ishidden="1" type="String">
					<name>part_resample4</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>$which_iqtree &gt; 200 &amp;&amp; $use_bnni &amp;&amp; !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $part_resample) ? "-bsam $part_resample -keep_empty_seq":""</code>
						</format>
					</attributes>
				</parameter>
				
				<parameter type="Switch">
					<name>write_boottrees</name>
					<attributes>
						<prompt>Turn on writing bootstrap trees to .ufboot file (-wbt)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value) ? "-wbt":""</code>
						</format>
						<vdef>
							<value>0</value>
						</vdef>
						<comment>
						<value>
Turn on writing bootstrap trees to .ufboot file. DEFAULT: OFF
						</value>
						</comment>
					</attributes>
				</parameter>
				
				<parameter type="Switch">
					<name>write_boottrees1</name>
					<attributes>
						<prompt>Turn on writing bootstrap trees with branch lengths (-wbtl)</prompt>
						<precond>
							<language>perl</language>
							<code>defined $bootstrap_type</code>
						</precond>
						<format>
							<language>perl</language>
							<code>($value) ? "-wbtl":""</code>
						</format>
						<vdef>
							<value>0</value>
						</vdef>
						<comment>
						<value>
Turn on writing bootstrap trees with branch lengths (-wbt1) DEFAULT: OFF
						</value>
						</comment>
					</attributes>
				</parameter>
				
			</parameters>
	</paragraph>
</parameter>

<!-- TEST OF SYMMETRY:
  -*symtest               Perform three tests of symmetry
  -*symtest-only      Do -*symtest then exit (not supported)
  -*symtest-remove-bad    Do *-symtest and remove bad partitions
  -*symtest-remove-good   Do -*symtest and remove good partitions
  -*symtest-type MAR|INT  Use MARginal/INTernal test when removing partitions
  -*symtest-pval NUMER    P-value cutoff (default: 0.05)
  -*symtest-keep-zero     Keep NAs in the tests
 -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>symmetry_tests</name>
 	<prompt>Symmetry Tests</prompt>
 		<parameters>
			
				
				<parameter type="Switch">
					<name>use_symmtest</name>
					<attributes>
						<prompt>Run symmetry test(s)</prompt>
												<precond>
							<language>perl</language>
							<code> !$specify_commandline</code>
						</precond>
						<vdef>
							<value>0</value>
						</vdef>
					</attributes>
				</parameter>
					
				<parameter ismandatory="0" type="Excl">
 					<name>specify_symtest</name>
 					<attributes>
 						<prompt>Symmetry Test (--symtest)</prompt>
  				<precond>
							<language>perl</language>
							<code>$use_symmtest</code>
						</precond>		
						<vlist>
							<value>symtest</value>
							<label>Symtest</label>
							<value>symtest-remove-bad</value>
							<label>Symtest and remove bad</label>
							<value>symtest-remove-good</value>
							<label>Symtest and remove good</label>
							<value>symtest-keep-zero</value>
							<label>Symtest Keep Zero</label>
						</vlist>
						<flist>
							<value>symtest</value>
							<code>"--symtest"</code>
							<value>symtest-remove-bad</value>
							<code>"--symtest-remove-bad"</code>
							<value>symtest-remove-good</value>
							<code>"--symtest-remove-good"</code>
							<value>symtest-keep-zero</value>
							<code>"--symtest-keep-zero"</code>
						</flist>
						<group>91</group>
 					</attributes>
 				</parameter>	
 								
				<parameter type="Excl">
 					<name>specify_symtype</name>
 					<attributes>
 						<prompt>When removing partitions,  use</prompt>
						<precond>
							<language>perl</language>
							<code> !$specify_commandline</code>
						</precond>
						<vlist>
							<value>pval</value>
							<label>PVAL</label>
							<value>MAR</value>
							<label>MARginal</label>
							<value>INT</value>
							<label>INTernal</label>
						</vlist>
						<format>
							<language>perl</language>
							<code>($value ne $vdef) ? "--symtest-type $value":""</code>
						</format>
						<vdef>
							<value>pval</value>
						</vdef>
<!--						<ctrls>
							<ctrl>
								<message>Please select the method to remove partitions </message>
								<language>perl</language>
								<code>($specify_symtest eq "symtest-remove-bad" || $specify_symtest eq "symtest-remove-good" ) &amp;&amp; !defined $specify_symtype </code>
							</ctrl>
						</ctrls>-->
						<group>92</group>
 					</attributes>
 				</parameter>				
 										
				<parameter type="Float">
 					<name>specify_pval</name>
 					<attributes>
 						<prompt>Specify a Symmetry p-value other than 0.05</prompt>
 						<precond>
							<language>perl</language>
							<code> !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>defined $value ? "--symtest-pval $specify_pval":""</code>
						</format>
 					<ctrls>
							<ctrl>
								<message>Please enter a pval for symmetry</message>
								<language>perl</language>
								<code>!defined $specify_pval &amp;&amp; $specify_symtest eq "symtest-pval"</code>
							</ctrl>
						</ctrls>
						<group>92</group>
						<comment>
<value>IQ-TREE provides three matched-pairs tests of symmetry (Naser-Khdour et al., 2019) to test the two assumptions of stationarity and homogeneity. 
iqtree2 -s example.phy -p example.nex --symtest will perform the three tests of symmetry on every partition of the alignment and print the result into a .symtest.csv file. 
You can configure the analysis to judge by pval, intval, or marval. You can set the p-value for whichever you choose to adjust the cutoff between good and bad partitions.
</value>
						</comment>
					</attributes>
 				</parameter>
 					
		</parameters>			
 	</paragraph>				
 </parameter>
				
<!-- The following single branch tests are faster than all bootstrap analysis and recommended for extremely large data sets (e.g., >10,000 taxa):

-alrt Specify number of replicates (>=1000) to perform SH-like approximate likelihood ratio test (SH-aLRT) (Guindon et al., 2010). If number of replicates is set to 0 (-alrt 0), then the parametric aLRT test (Anisimova and Gascuel 2006) is performed, instead of SH-aLRT. 
-abayes Perform approximate Bayes test (Anisimova et al., 2011). 
-lbp Specify number of replicates (>=1000) to perform fast local bootstrap probability method (Adachi and Hasegawa, 1996). 
 -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>single_branchtest</name>
 	<prompt>Single Branch Tests</prompt>
 		<parameters>
				
				<parameter type="Switch">
 					<name>sh_test</name>
 					<attributes>
 						<prompt>SH-Like Test (-alrt)</prompt>
 						<precond>
							<language>perl</language>
							<code>$bootstrap_type ne "b" &amp;&amp; $bootstrap_type ne "bo" &amp;&amp; $bootstrap_type ne "bc" &amp;&amp;  !$specify_commandline</code>
							</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-alrt $num_replicates":""</code>
						</format>
						<group>6</group>
 					</attributes>
 				</parameter>
 				
 <!-- for the parametricaLRT test  -->
 				<parameter type="Switch">
 					<name>parametrical_test</name>
 					<attributes>
 						<prompt>Run the parametricaLRT test (-alrt 0)</prompt>
 						<precond>
							<language>perl</language>
							<code>$bootstrap_type ne "b" &amp;&amp; $bootstrap_type ne "bo" &amp;&amp; $bootstrap_type ne "bc" &amp;&amp;  !$specify_commandline</code>
						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-alrt 0":""</code>
						</format>
						<group>6</group>
 					</attributes>
 				</parameter>
 								
				<parameter type="Switch">
 					<name>abayes_test</name>
 					<attributes>
 						<prompt>Approximate Bayes test (-abayes)</prompt>	
 						<precond>
							<language>perl</language>
							<code>$bootstrap_type ne "b" &amp;&amp; $bootstrap_type ne "bo" &amp;&amp; $bootstrap_type ne "bc" &amp;&amp;  !$specify_commandline</code>
						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-abayes":""</code>
						</format>
						<group>6</group>
 					</attributes>
 				</parameter>
 				
 				<parameter type="Switch">
 					<name>lbp_test</name>
 					<attributes>
 						<prompt>Fast local bootstrap probability (-lbp)</prompt>
 						<precond>
							<language>perl</language>
							<code>$bootstrap_type ne "b" &amp;&amp; $bootstrap_type ne "bo" &amp;&amp; $bootstrap_type ne "bc" &amp;&amp;  !$specify_commandline</code>
						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-lbp $num_replicates":""</code>
						</format>
						<group>6</group>
 					</attributes>
 				</parameter>
 				
 				<parameter type="Integer">
					<name>num_replicates</name>
					<attributes>
						<prompt>Specify number of replicates (1000 or more)</prompt>
						<precond>
							<language>perl</language>
							<code>$sh_test || $lbp_test</code>
						</precond>
						<ctrls>
							<ctrl>
								<message>The value of replicates must be greater than or equal to 1,000</message>
								<language>perl</language>
								<code>defined $num_replicates &amp;&amp; $num_replicates &lt; 1000 &amp;&amp; $lbp_test</code>
							</ctrl>
							<ctrl>
								<message>The value of replicates must be greater than or equal to 1,000 for the SH- test </message>
								<language>perl</language>
								<code>defined $num_replicates &amp;&amp; $sh_test  &amp;&amp; $num_replicates &lt; 1000 </code>
							</ctrl>
							<ctrl>
								<message>Please enter a value for number of replicates </message>
								<language>perl</language>
								<code>!defined $num_replicates &amp;&amp; ($sh_test  || $lbp_test)</code>
							</ctrl>
						</ctrls>					
					</attributes>
				</parameter>
		</parameters>			
 	</paragraph>				
 </parameter>
 
 <!-- ancestral state reconstruction -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>ancestral_reconstruction</name>
 	<prompt>Ancestral State Reconstruction</prompt>
 		<parameters> 
 
 <!-- 
 -asr Write ancestral sequences (by empirical Bayesian method) for allnodes of the tree to.statefile.
 -asr-min Specify the minimum threshold of posterior probability to determinethe best ancestral state. 
 Default: observed state frequency from thealignment.
 -te specify a user-defined tree to determine ancestral sequences along this tree. You can assign each node of this tree 
 with a node name, and IQ-TREE will report the ancestral sequences of the correspondingnodes. If nodes do not have names, 
 IQ-TREE will automatically assign node names as Node1, Node2, etc.-->	
 	
				<parameter type="Switch">
					<name>write_ancestralseqs</name>
					<attributes>
						<prompt>Write ancestral sequences to .statefile (-asr)</prompt>
						<precond>
							<language>perl</language>
							<code>$which_iqtree &gt; 19 &amp;&amp;  !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>$value ? "-asr":""</code>
						</format>
					</attributes>
				</parameter>
				
				<parameter type="Float">
					<name>specify_ancestralthresh</name>
					<attributes>
						<prompt>Specify minimum threshold of posterior probability for best ancestral state (-asr-min)</prompt>
						<precond>
							<language>perl</language>
							<code>$which_iqtree &gt; 19 &amp;&amp;  !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>$value ? "-asr-min $value":""</code>
						</format>
					</attributes>
				</parameter>
									
				<parameter type="InFile">
					<name>specify_ancestraltree</name>
					<attributes>
						<prompt>Specify a user-defined tree to determine ancestral sequences (-te)</prompt>
						<precond>
							<language>perl</language>
							<code>$which_iqtree &gt; 19</code>
						</precond>
						<filenames>ancestralseqs.tre</filenames>
						<warns>
							<warn>
									<message>Note that your ancestral sequences file will be named ancestralseqs.tre; your command line must include -te ancestralseqs.tre</message>
									<language>perl</language>
									<code> defined $specify_ancestraltree &amp;&amp; $specify_commandline</code>
							</warn>
						</warns>
					</attributes>
				</parameter>
 		
 			<parameter ishidden="1" type="String">
					<name>specify_ancestraltree2</name>
					<attributes>
						<precond>
							<language>perl</language>
							<code>defined $specify_ancestraltree &amp;&amp;  !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>"-te ancestralseqs.tre"</code>
						</format>
					</attributes>
				</parameter>
 		</parameters>
 		
 	</paragraph>
 </parameter>
 
<!-- Tree Topology Tests -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>tree_topology</name>
 	<prompt>Tree Topology Tests</prompt>
 		<parameters>
 		
<!--  -z Specify a file containing a set of trees. IQ-TREE will compute the log-likelihoods of all trees. -->				
				<parameter type="InFile">
 					<name>specify_treefile</name>
 					<attributes>
 						<prompt>Specify a file containing a set of trees (-z)</prompt>
						<filenames>treesfile.tre</filenames>
			<warns>
				<warn>
					<message>Note that your tree file will be named treesfile.tre; your command line must include -z treesfile.tre</message>
					<language>perl</language>
					<code> defined $specify_treefile &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
 					</attributes>
 				</parameter>
 				
 			<parameter ishidden="1" type="String">
 					<name>specify_treefile2</name>
 					<attributes>
 					 	<precond>
							<language>perl</language>
							<code>defined $specify_treefile &amp;&amp;  !$specify_commandline</code>
						</precond>
 						<format>
							<language>perl</language>
							<code>"-z treesfile.tre"</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!-- -zb Specify the number of RELL (Kishino et al., 1990) replicates (>=1000) to perform several tree topology tests for all trees passed via -z. The tests include bootstrap proportion (BP), KH test (Kishino and Hasegawa, 1989), SH test (Shimodaira and Hasegawa, 1999) and expected likelihood weights (ELW) (Strimmer and Rambaut, 2002). -->  								
				<parameter type="Integer">
 					<name>num_rell</name>
 					<attributes>
 						<prompt>Specify the number of RELL replicates (-zb)</prompt>	
 						 <precond>
							<language>perl</language>
							<code>!$specify_commandline</code>
						</precond>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-zb $value":""</code>
						</format>
						<ctrls>
							<ctrl>
								<message>Sorry, the number of RELL replicates cannot be less than 1,000</message>
								<language>perl</language>
								<code>defined $num_rell &amp;&amp; $num_rell &lt; 1000 &amp;&amp;  !$specify_commandline</code>
							</ctrl>
						</ctrls>
						<comment>
<value>-zb Specify the number of RELL (Kishino et al., 1990) replicates (>=1000) to perform several tree topology tests for all trees passed via -z. The tests include bootstrap proportion (BP), KH test (Kishino and Hasegawa, 1989), SH test (Shimodaira and Hasegawa, 1999) and expected likelihood weights (ELW) (Strimmer and Rambaut, 2002).</value>
						</comment>
 					</attributes>
 				</parameter>
 				
<!-- -zw Used together with -zb to additionally perform the weighted-KH and weighted-SH tests. -->
 				<parameter type="Switch">
 					<name>weighted_tests</name>
 					<attributes>
 						<prompt>Perform the weighted-KH and weighted-SH tests (-zw)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $num_rell</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-zw":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!-- -au Used together with -zb to additionally perform the approximately unbiased (AU) test (Shimodaira, 2002). Note that you have to specify the number of replicates for the AU test via -zb. -->
  				<parameter type="Switch">
 					<name>unbiased_test</name>
 					<attributes>
 						<prompt>Perform the approximately unbiased (AU) test</prompt>	
 						  <precond>
							<language>perl</language>
							<code> !$specify_commandline</code>
						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-au":""</code>
						</format>
						<ctrls>
							<ctrl>
								<message>Note that you have to specify the number of replicates for the AU test via-zb</message>
								<language>perl</language>
								<code>$unbiased_test &amp;&amp; !defined $num_rell</code>
							</ctrl>
						</ctrls>
 					</attributes>
 				</parameter>
 				
 <!-- Only estimate model parameters on an initial parsimony tree and ignore a full tree search to save time.  -->
   				<parameter type="Switch">
 					<name>estimate_parsetreeonly</name>
 					<attributes>
 						<prompt>Only estimate model parameters on an initial parsimony tree (-n 0)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $num_rell</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-n 0":""</code>
						</format>
						<comment>
<value>Only estimate model parameters on an initial parsimony tree and ignorea full tree search to save time.</value>
						</comment>
 					</attributes>
 				</parameter>
 				
<!-- -te Specify a fixed user tree to estimate model parameters. Thus it behaves like -n 0 but uses a user-defined tree instead of parsimony tree. -->
 				<parameter type="InFile">
					<name>fixed_usertree</name>
					<attributes>
						<prompt>Specify a fixed user tree to estimate model parameters (-te)</prompt>
						<filenames>fixed_usertree.tre</filenames>
			<warns>
				<warn>
					<message>Note that your fixed user tree file will be named fixed_usertree.tre; your command line must include -te fixed_usertree.tre</message>
					<language>perl</language>
					<code> defined $fixed_usertree &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
						<comment>
<value>-te Specify a fixed user tree to estimate model parameters. Thus it behaves like -n 0 but uses a user-defined tree instead of parsimony tree. 
						</value>
						</comment>						
					</attributes>
				</parameter>
				
				 <parameter ishidden= "1" type="String">
					<name>fixed_usertree2</name>
					<attributes>
					 	 <precond>
							<language>perl</language>
							<code> defined $fixed_usertree &amp;&amp; !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>"-te fixed_usertree.tre"</code>
						</format>					
					</attributes>
				</parameter>

		</parameters>			
 	</paragraph>				
 </parameter>
 				
 				
<!-- Constructing consensus tree IQ-TREE provides a fast implementation of consensus tree construction for post analysis: -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>consensus_tree</name>
 	<prompt>Consensus Trees</prompt>
 		<parameters>
 		
<!--  -t Specify a file containing a set of trees.  -->				
				<parameter type="InFile">
 					<name>tree_file1</name>
 					<attributes>
 						<prompt>Specify a file containing a set of trees</prompt>
						<filenames>treefile1.tre</filenames>
			<warns>
				<warn>
					<message>Note that your set of trees  file will be named treefile1.tre; your command line must include -t treefile1.tre</message>
					<language>perl</language>
					<code> defined $tree_file1 &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
 					</attributes>
 				</parameter>
 				
 				<parameter ishidden="1" type="String">
 					<name>tree_file2</name>
 					<attributes>
 					 <precond>
							<language>perl</language>
							<code> defined $tree_file1 &amp;&amp; !$specify_commandline</code>
						</precond>
 						<format>
							<language>perl</language>
							<code>"-t treefile1.tre"</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -con Compute consensus tree of the trees passed via -t. Resulting consensus tree is written to .contree file.  -->  								
				<parameter type="Switch">
 					<name>compute_consensustree</name>
 					<attributes>
 						<prompt>Compute consensus tree of the trees passed via -t (-con)</prompt>	
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1 &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-con":""</code>
						</format>
						<comment>
<value>-con Compute consensus tree of the trees passed via -t. Resulting consensus tree is written to .contree file.</value>
						</comment>
 					</attributes>
 				</parameter>
 				
<!--  -net Compute consensus network of the trees passed via -t. Resulting consensus network is written to .nex file.  -->
 				<parameter type="Switch">
 					<name>compute_consensusnetwork</name>
 					<attributes>
 						<prompt>Compute consensus network of the trees passed via -t (-net)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1 &amp;&amp; !$specify_commandline</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-net":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!-- -minsup Specify a minimum threshold (between 0 and 1) to keep branches in the consensus tree. -minsup 0.5 means to compute majority-rule consensus tree. DEFAULT: 0 to compute extended majority-rule consensus. -->
  				<parameter type="Float">
 					<name>min_threshold</name>
 					<attributes>
 						<prompt>Specify a minimum threshold between 0 and 1 (-minsup)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1 &amp;&amp; !$specify_commandline</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>($value) ? "-minsup $min_threshold":""</code>
						</format>
						<ctrls>
							<ctrl>
								<message>The value for -minsup must be between 0 and 1</message>
								<language>perl</language>
								<code>$min_threshold &lt; 0 || $min_threshold &gt; 1 &amp;&amp; !$specify_commandline</code>
							</ctrl>
						</ctrls>
 					</attributes>
 				</parameter>
 				
<!--  -bi Specify a burn-in, which is the number of beginning trees passed via -t to discard before consensus construction. This is useful e.g. when summarizing trees from MrBayes analysis.  -->
  				<parameter type="Integer">
 					<name>burnin_value</name>
 					<attributes>
 						<prompt>Specify a burn-in (-bi)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1 &amp;&amp; !$specify_commandline</code>
 						</precond>	
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-bi $value":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -sup Specify an input “target” tree file. That means, support values are first extracted from the trees passed via -t, and then mapped onto the target tree. Resulting tree with assigned support values is written to .suptree file. This option is useful to map and compare support values from different approaches onto a single tree.  -->
 				<parameter type="InFile">
					<name>target_treefile</name>
					<attributes>
						<prompt>Specify an input “target” tree file (-sup)</prompt>
						<filenames>targetfile.tre</filenames>
			<warns>
				<warn>
					<message>Note that your target tree  file will be named targetfile.tre; your command line must include -sup targetfile.tre</message>
					<language>perl</language>
					<code> defined $target_treefile &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
						<comment>
<value>-sup Specify an input “target” tree file. That means, support values are first extracted from the trees passed via -t, and then mapped onto the target tree. Resulting tree with assigned support values is written to .suptree file. This option is useful to map and compare support values from different approaches onto a single tree.
						</value>
						</comment>						
					</attributes>
				</parameter>
				
				 <parameter ishidden="1" type="String">
					<name>target_treefile2</name>
					<attributes>
 						<precond>
 							<language>perl</language>
 							<code>defined $target_treefile &amp;&amp; !$specify_commandline</code>
 						</precond>						
						<format>
							<language>perl</language>
							<code>"-sup targetfile.tre"</code>
						</format>					
					</attributes>
				</parameter>
								
<!-- -scale Set the scaling factor of support values for-supoption (default: 100,i.e. percentages) -->
				<parameter type="String">
					<name>set_scalefactor</name>
					<attributes>
						<prompt>Set the scaling factor of support values for -sup option (-scale)</prompt>
						<precond>
							 <language>perl</language>
							 <code>defined $target_treefile</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value) ? "-scale $value":""</code>
						</format>
						<comment>
						<value>
-suptag Specify name of a node in -sup target tree. The corresponding node of .suptree will then be assigned with IDs of trees where this node appears. Special option -suptag ALL will assign such IDs for all nodes of the target tree.
						</value>
						</comment>						
					</attributes>
				</parameter>
		
				
<!--  -prec Set the precision of support values for -supoption (default: 0) -->
				<parameter type="String">
					<name>set_precision</name>
					<attributes>
						<prompt>Set the precision of support values for -sup option (-prec)</prompt>
						<precond>
							 <language>perl</language>
							 <code>defined $target_treefile &amp;&amp; !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value) ? "-prec $value":""</code>
						</format>					
					</attributes>
				</parameter>

<!-- -suptag Specify name of a node in -sup target tree. The corresponding node of .suptree will then be assigned with IDs of trees where this node appears. Special option -suptag ALL will assign such IDs for all nodes of the target tree. --> 				
				<parameter type="String">
					<name>nodetarget_treefile</name>
					<attributes>
						<prompt>Specify name of a node in -sup target tree (-suptag)</prompt>
						<precond>
							 <language>perl</language>
							 <code>defined $target_treefile &amp;&amp; !$specify_commandline</code>
						</precond>
						<format>
							<language>perl</language>
							<code>(defined $value) ? "-suptag $value":""</code>
						</format>						
					</attributes>
				</parameter>

		</parameters>			
 	</paragraph>				
 </parameter>				

<!-- Computing Robinson-Foulds distance IQ-TREE provides a fast implementation of Robinson-Foulds (RF) distance computation between trees: -->

<!-- Constructing consensus tree IQ-TREE provides a fast implementation of consensus tree construction for post analysis: -->
 <parameter type="Paragraph">
 <paragraph>
 	<name>robinsons_fouldsdist</name>
 	<prompt>Computing Robinson's Foulds distances</prompt>
 		<parameters>
 		
<!--  -rf Specify a second set of trees. IQ-TREE computes all pairwise RF distances between two tree sets passed via -t and -rf  -->	
				<parameter type="InFile">
 					<name>tree_file2</name>
 					<attributes>
 						<prompt>Specify a second set of trees for RF distances (-rf)</prompt>
						<filenames>treefile2.tre</filenames>
			<warns>
				<warn>
					<message>Note that your second set of trees file will be named treefile2.tre; your command line must include -rf treefile2.tre</message>
					<language>perl</language>
					<code> defined $tree_file2 &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
 					</attributes>
 				</parameter>
 							
				<parameter ishidden="1" type="String">
 					<name>tree_file2b</name>
 					<attributes>
						  <precond>
							<language>perl</language>
							<code> defined $tree_file2 &amp;&amp; !$specify_commandline</code>
						</precond>
 						<format>
							<language>perl</language>
							<code>"-rf treefile2.tre"</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -rf_all Compute all-to-all RF distances between all trees passed via -t -->								
				<parameter type="Switch">
 					<name>compute_rfdistances_all</name>
 					<attributes>
 						<prompt>Compute all-to-all RF distances between all trees passed via -t (-rf_all)</prompt>	
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1 &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-rf_all":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -rf_adj Compute RF distances between adjacent trees passed via -t -->
				<parameter type="Switch">
 					<name>compute_rfdistances_adj</name>
 					<attributes>
 						<prompt>Compute RF distances between adjacent trees passed via -t (-rf_adj)</prompt>	
 						<precond>
 							<language>perl</language>
 							<code>defined $tree_file1 &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-rf_adj":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
 				<parameter type="InFile">
 					<name>specify_rfdistancestree</name>
 					<attributes>
 						<prompt>Select file of adjacent trees to pass via -t</prompt>	
 						<filenames>rfdistance.tre</filenames>
 			<warns>
				<warn>
					<message>Note that your set of adjacent trees file will be named rfdistance.tre; your command line must include -t rfdistance.tre</message>
					<language>perl</language>
					<code> defined $specify_rfdistancestree &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
 					</attributes>
 				</parameter>
 				
 				 <parameter ishidden="1" type="String">
 					<name>specify_rfdistancestree2</name>
 					<attributes>
 						<precond>
 							<language>perl</language>
 							<code>defined $specify_rfdistancestree &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>"-t rfdistance.tre"</code>
						</format>
 					</attributes>
 				</parameter>

		</parameters>			
 	</paragraph>				
 </parameter>

<!-- Generating random trees: IQ-TREE provides several random tree generation models: -->

<!--  -r Specify number of taxa. IQ-TREE will create a random tree under Yule-Harding model with specified number of taxa -->
<!--  -ru Like -r, but a random tree is created under uniform model.  -->
<!--  -rcat Like -r, but a random caterpillar tree is created.  -->
<!--  -rbal Like -r, but a random balanced tree is created.  -->
<!--  -rcsg Like -r, bur a random circular split network is created.  -->
<!--  -rlen Specify three numbers: minimum, mean and maximum branch lengths of the random tree. DEFAULT:  -->
 
 <parameter type="Paragraph">
 <paragraph>
 	<name>generate_randomtrees</name>
 	<prompt>Generate Random Trees (Only)</prompt>
 		<parameters>
 		
<!--  -r Specify number of taxa. IQ-TREE will create a random tree under Yule-Harding model with specified number of taxa -->				
				<parameter type="Integer">
 					<name>num_taxa</name>
 					<attributes>
 					 	<prompt>Specify number of taxa for the tree (-r)</prompt>
 					 	<precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
 						<ctrls>
 							<ctrl>
 								<message>Please choose a random tree model</message>
 								<language>perl</language>
 								<code>!defined $choose_randomtype &amp;&amp; defined $num_taxa </code>
 							</ctrl>
 						</ctrls>
 						<warns>
							<warn>
								<message>If you select a random tree option, the program will create a random tree and exit without further action</message>
								<language>perl</language>
								<code>defined $num_taxa</code>
							</warn>
						</warns>
 					</attributes>
 				</parameter>
 				
<!--  -ru Like -r, but a random tree is created under uniform model.  -->								
				<parameter ismandatory="0" type="Excl">
 					<name>choose_randomtype</name>
 					<attributes>
 						<prompt>Specify a model for the random trees</prompt>	
 							<precond>
 								<language>perl</language>
 								<code>defined $num_taxa &amp;&amp; !$specify_commandline</code>
 							</precond>
						<vlist>
 							<value>-r</value>
 							<label>Yule-Harding model</label>
 							<value>-ru</value>
 							<label>Uniform</label>
 							<value>-rcat</value>
 							<label>Caterpillar</label>
 							<value>-rbal</value>
 							<label>Balanced</label>
 							<value>-rcsg</value>
 							<label>Circular Split</label>
 						</vlist>
 						 <format>
							<language>perl</language>
							<code>(defined $value) ? "$value $num_taxa $specify_treefilename":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--  -rlen Specify three numbers: minimum, mean and maximum branch lengths of the random tree. DEFAULT:  -->						
				<parameter type="String">
 					<name>specify_brlengths</name>
 					<attributes>
 						<prompt>Specify minimum, mean and maximum branch lengths of the random tree DEFAULT:-rlen 0.001 0.1 0.999</prompt>
 						 	<precond>
 								<language>perl</language>
 								<code>defined $num_taxa &amp;&amp; !$specify_commandline</code>
 							</precond>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-rlen $value":""</code>
						</format>
						<comment>
<value>Specify three numbers: minimum, mean and maximum branch lengths of the random tree. </value>
						</comment>
 					</attributes>
 				</parameter>

<!--  a name for the tree file 				-->	
				<parameter type="String">
 					<name>specify_treefilename</name>
 					<attributes>
 						<prompt>Specify a name for your random tree file (we recommend a name with .tree)</prompt>
 						 <precond>
 								<language>perl</language>
 								<code>defined $num_taxa &amp;&amp; !$specify_commandline</code>
 							</precond>
 						<ctrls>
 							<ctrl>
 								<message>Please specify a name for your random tree file output</message>
 								<language>perl</language>
 								<code>defined $num_taxa &amp;&amp; !defined $specify_treefilename</code>
 							</ctrl>
 							<ctrl>
 								<message>Sorry, you cant specify random trees and provide a starting tree</message>
 								<language>perl</language>
 								<code>defined $tree_file1 &amp;&amp; defined $specify_treefilename</code>
 							</ctrl>
 						</ctrls>
						<comment>
<value>Specify a name for the random tree output. Consider adding the .tree extension</value>
						</comment>
 					</attributes>
 				</parameter>

		</parameters>			
 	</paragraph>				
 </parameter>

<!-- Miscellaneous options -->

<!-- -wt Turn on writing all locally optimal trees into .treels file. DEFAULT: OFF  -->
<!-- -fixbr Turn on fixing branch lengths of tree passed via -t or -te. This is useful to evaluate the log-likelihood of an input tree with fixed tolopogy and branch lengths. DEFAULT: OFF  -->
<!-- -wslg Turn on writing site log-likelihoods per rate category. DEFAULT: OFF  -->
<!-- -fconst Specify a list of comma-separated integer numbers. The number of entries should be equal to the number of states in the model (e.g. 4 for DNA and 20 for protein). IQ-TREE will then add a number of constant sites accordingly. For example, -fconst 10,20,15,40 will add 10 constant sites of all A, 20 constant sites of all C, 15 constant sites of all G and 40 constant sites of all T into the alignment. 
 -->
<parameter type="Paragraph">
 	<paragraph>
 	<name>cf_options</name>
 	<prompt>Concordance Factor Options (Version 2 only)</prompt>
 		<parameters>
<!-- As an example, you can apply an edge-linked proportional partition model with ultra-fast bootstrap 
(1000 replicates; for comparison with concordance factors):iqtree -s ALN_FILE -p PARTITION_FILE 
-*prefix concat -B 1000 -T AUTO where ALN_FILE and PARTITION_FILE are your input files.-T AUTO is to detect 
the best number of CPU cores. Here we use a prefix concat, so that all output files (concat.*) do not 
interfere with analyses below. If -*prefix is omitted, all output files will be PARTITION_FILE. -->
<!-- Given the species tree concat.treefile and the set of locus trees loci.treefile computed above, you can calculate gCF for each branch of the species tree as the fraction of 
decisive gene trees concordant with this branch:

iqtree2 -t concat.treefile -*gcf loci.treefile -*prefix concord

Note that -t accepts any reference tree (e.g., by coalescent/reconciliation approach) and -*gcf accepts any set of trees (e.g. locus trees and bootstrap trees), which may contain a subset of taxa from the reference tree. IQ-Tree will write three files:

    concord.cf.tree: Newick tree with gCF assigned for each internal branch of the reference tree. If the reference tree already has some branch label (such as bootstrap support in this case), gCF will be appended to the existing label separated by a /.
    concord.cf.branch: Newick tree with internal branch IDs.
    concord.cf.stat: A tab-separated table with gCF and gDF (gene discordance factor) for every internal branch (rows of the table). The ID column can be linked with concord.cf.branch file. This file can be read in R to do some plot (see below).

If you omit -*prefix, all output files will be written to concat.treefile.*. -->
 			<parameter type="InFile"> 
 					<name>partition_modelfile2</name>
 					<attributes>
 						<prompt>Choose file that specifies the model selection (-S)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200</code>
 						</precond>
						<filenames>alignment_file.txt</filenames>
						<ctrls>
							<ctrl>
								<message>You cannot specify a -S file and a -p partition file </message>
								<language>perl</language>
								<code>defined $partition_modelfile2 &amp;&amp; defined $partition_file</code>
							</ctrl>
						</ctrls>
						<warns>
				<warn>
					<message>Note that your set of model selection file will be named alignment_file.txt; your command line must include -S alignment_file.txt</message>
					<language>perl</language>
					<code> defined $partition_modelfile2 &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
 		</attributes>
 	</parameter>
 				
 				 <parameter ishidden="1" type="String"> 
 					<name>partition_modelfile2b</name>
 					<attributes>
 						 <precond>
 								<language>perl</language>
 								<code>defined $partition_modelfile2 &amp;&amp; !$specify_commandline</code>
 							</precond>
 						<format>
							<language>perl</language>
							<code> "-S alignment_file.txt"</code>
						</format>
 					</attributes>
 				</parameter>
 				
   				 <parameter type="String"> 
 					<name>name_outfiles</name>
 					<attributes>
 						<prompt>Specify a prefix for the output files (--prefix)</prompt>
 						<precond>
 								<language>perl</language>
 								<code>!$specify_commandline</code>
 							</precond>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "--prefix $value":""</code>
						</format>
						<ctrls>
							<ctrl>
								<message>You have entered two different prefixes. Please remove one.</message>
								<language>perl</language>
								<code>defined $name_outfiles &amp;&amp; defined $specify_prefix</code>
							</ctrl>
					</ctrls>
 					</attributes>
 				</parameter> 
 	
 	 			<parameter type="InFile"> 
 					<name>partition_tfile</name>
 					<attributes>
 						<prompt>Choose a reference tree file (coalescent/reconciliation approach) for gCF (-t)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200</code>
 							</precond>
						<filenames>concat.treefile</filenames>
						<warns>
				<warn>
					<message>Note that your reference tree file for gCF will be named concat.treefile.tre; your command line must include -t concat.treefile</message>
					<language>perl</language>
					<code> defined $partition_tfile &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
			<comment>
<value>Note that -t accepts any reference tree (e.g., by coalescent/reconciliation approach) and --gcf accepts any set of trees (e.g. locus trees and bootstrap trees), which may contain a subset of taxa from the reference tree. IQ-Tree will write three files:
 concord.cf.tree: Newick tree with gCF assigned for each internal branch of the reference tree. If the reference tree already has some branch label (such as bootstrap support in this case), gCF will be appended to the existing label separated by a /.
 concord.cf.branch: Newick tree with internal branch IDs.
 concord.cf.stat: A tab-separated table with gCF and gDF (gene discordance factor) for every internal branch (rows of the table). 
 The ID column can be linked with concord.cf.branch file. This file can be read in R to do some plotting.</value>
			</comment>
 					</attributes>
 				</parameter>			
 				
 				<parameter ishidden="1" type="String"> 
 					<name>partition_tfile2</name>
 					<attributes>
 						 <precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200 &amp;&amp; defined $partition_tfile &amp;&amp; !$specify_commandline</code>
 							</precond>
 						<format>
							<language>perl</language>
							<code> "-t concat.treefile"</code>
						</format>
 					</attributes>
 				</parameter>

 				<parameter type="InFile"> 
 					<name>setoftrees_file</name>
 					<attributes>
 						<prompt>Choose a set of trees for gCF (-gcf)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200</code>
 						</precond>
						<filenames>loci.treefile</filenames>
						<warns>
				<warn>
					<message>Note that your set of trees for gCF will be named loci.treefile; your command line must include -gcf loci.treefile</message>
					<language>perl</language>
					<code> defined $setoftrees_file &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
 					</attributes>
 				</parameter>
 				
 				 <parameter ishidden="1" type="String"> 
 					<name>setoftrees_file2</name>
 					<attributes>
 						 <precond>
 							<language>perl</language>
 							<code>defined $setoftrees_file &amp;&amp; !$specify_commandline</code>
 							</precond>
 						<format>
							<language>perl</language>
							<code>"--gcf loci.treefile"</code>
						</format>
 					</attributes>
 				</parameter>
 								
 					
 				
 			</parameters>
 		</paragraph>
</parameter>

<parameter type="Paragraph">
 	<paragraph>
 	<name>dating_options</name>
 	<prompt>Dating Options (Version 2 only)</prompt>
 		<parameters>
 		
<!-- Phylogenetic Dating. Since IQ-TREE 2.0.3, we integrate the least square dating (LSD2) 
method to build a time tree when you have date information for tips or ancestral nodes. 
So if you use this feature please cite: 
TIME TREE RECONSTRUCTION:
yes -*date FILE			Dates of tips or ancestral nodes
yes -*date TAXNAME		Extract dates from taxon names after last'|'
-*date-tip STRING   Tip dates as a real number or YYYY-MM-DD
-*date-root STRING  Root date as a real number or YYYY-MM-DD
-*date-ci  NUM 		Number of replicates to compute confidenceinterval
-*clock-sd NUM 		Std-devforlognormal relaxed clock (default: 0.2)
-*date-outlier NUM    Z-score cutoff to exclude outlier nodes (e.g. 3)
-*date-options ".."  Extra options passing directly to LSD2 -->

				<parameter type="InFile"> 
 					<name>specify_datefile</name>
 					<attributes>
 						<prompt>Choose a file that specifies dates (--date)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200</code>
 						</precond>
						<filenames>date_file.txt</filenames>
						<warns>
				<warn>
					<message>Note that your date file will be named date_file.txt; your command line must include --date date_file.txt</message>
					<language>perl</language>
					<code> defined $specify_datefile &amp;&amp; $specify_commandline</code>
				</warn>
			</warns>
 					</attributes>
 				</parameter>
 				
 				<parameter ishidden="1" type="String"> 
 					<name>specify_datefile2</name>
 					<attributes>
 						<precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200 &amp;&amp; defined $specify_datefile &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code> "--date date_file.txt"</code>
						</format>
 					</attributes>
 				</parameter>

				<parameter type="Switch"> 
 					<name>extract_datefile</name>
 					<attributes>
 						<prompt>Automatically extract dates from taxon Names (--date TAXNAME)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>defined $specify_datefile &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "--date TAXNAME":""</code>
						</format>
 					</attributes>
 				</parameter> 
 				
 <!-- -*date-tip STRING     Tip dates as a real number or YYYY-MM-DD -->
				<parameter type="String"> 
 					<name>specify_datetip</name>
 					<attributes>
 						<prompt>Specify tip dates as a real number or YYYY-MM-DD (--date-tip)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200 &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "--date-tip $value":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
 <!-- -*date-root STRING    Root date as a real number or YYYY-MM-DD -->		 
				<parameter type="String"> 
 					<name>specify_rootdate</name>
 					<attributes>
 						<prompt>Specify root date as a real number or YYYY-MM-DD (--date-root)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200 &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "--date-root $value":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
 <!-- If you already have a tree, you can use option-te TREE_FILE to ask IQ-TREE to load and 
 fix this tree topology:iqtree -s ALN_FILE -*date DATE_FILE -te TREE_FILE. This will work with the 
 scenarios above, i.e., IQ-TREE will date the user-defined treeinstead of the ML tree.  To further 
 speed up the process: If you know the model already, you set can it via -m option; or in a 
 partitioned analysis, you can provide apartition file with specified models. -->
				<parameter type="InFile"> 
 					<name>specify_datetreefile</name>
 					<attributes>
 						<prompt>Load and fix this tree topology (-te)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200</code>
 						</precond>
						<filenames>treetopology.txt</filenames>
						<warns>
							<warn>
								<message>Note that your fixed tree topology file will be named treetopology.txt; your command line must include -te treetopology.txt</message>
								<language>perl</language>
								<code> defined $specify_datetreefile &amp;&amp; $specify_commandline</code>
							</warn>
						</warns>
 					</attributes>
 				</parameter>
 				
 				<parameter ishidden="1" type="String"> 
 					<name>specify_datetreefile2</name>
 					<attributes>
 						 <precond>
 							<language>perl</language>
 							<code>defined $specify_datetreefile &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>"--date treetopology.txt"</code>
						</format>
 					</attributes>
 				</parameter>

<!--  resample branch lengths 100 times to infer the confidence interval -->
				<parameter type="Integer"> 
 					<name>specify_resampleint</name>
 					<attributes>
 						<prompt>Resample branch lengths to infer the confidence interval  (--date-ci)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200 &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value &gt; 0 ) ? "--date-ci $value":""</code>
						</format>
				<!--  		<ctrls>
							<ctrl>
								<message>Please enter a value for resampling branch length confidence interval</message>
								<language>perl</language>
								<code>!defined $specify_resampleint</code>
							</ctrl>
							<ctrl>
								<message>Please enter a value for resampling branch length confidence interval that is greater than zero</message>
								<language>perl</language>
								<code>$specify_resampleint &lt;= 0 </code>
							</ctrl>
						</ctrls>-->
 					</attributes>
 				</parameter>

<!--  z-score threshold to detect outliers. --> 
				<parameter type="Float"> 
 					<name>specify_outlierthresh</name>
 					<attributes>
 						<prompt>z-score threshold to detect outliers (--date-outlier)</prompt>
 						<precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200 &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "--date-outlier $value":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
 <!--  date options not exposed. 
				<parameter type="Float"> 
 					<name>specify_resampleint</name>
 					<attributes
 						<prompt>z-score threshold to detect outliers (-*date-outlier)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>$which_iqtree &gt; 200</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>(defined $value) ? "-*date-outlier $value":""</code>
						</format>
 					</attributes>
 				</parameter>--> 
 						
 		</parameters>
 	</paragraph>
</parameter>
 

 <parameter type="Paragraph">
 <paragraph>
 	<name>misc_options</name>
 	<prompt>Miscellaneous Options</prompt>
 		<parameters>
 <!-- -alninfo Print alignment site statistics to.alninfofile.
      -blfix   Fix branch lengths of tree passed via -tor or -te. This is useful to evaluate the log-likelihood of an 
      input tree with fixed tolopogy andbranch lengths.DEFAULT: OFF
      -blmin   Specify minimum branch length. Default: the smaller of 0.000001 and 0.1/alignment_length.
      -blmax   Specify the maximum branch length. Default: 10-czbCollapse near zero branches, so that the final tree may 
               be multifurcating. This is useful for bootstrapping in the presence ofpolytomy to reduce bootstrap supports
               of short branches.
      -me      Specify the log-likelihood epsilon for final model parameter estimation(Default: 0.01). With-fastoption, the 
               epsilon is raised to 0.05.
 -->
 
 <!--   -alninfo Print alignment site statistics to.alninfofile. DEFAULT: OFF  -->				
				<parameter type="Switch"> 
 					<name>print_sitestats</name>
 					<attributes>
 						<prompt>Print alignment site statistics to.alninfofile (-alninfo)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code> !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-alninfo":""</code>
						</format>
						<group>90</group>
 					</attributes>
 				</parameter>	
 				
 <!-- -blfix   Fix branch lengths of tree passed via -tor or -te. This is useful to evaluate the log-likelihood of an 
      input tree with fixed tolopogy andbranch lengths.DEFAULT: OFF -->
 				<parameter type="Switch"> 
 					<name>fix_branchlengths</name>
 					<attributes>
 						<prompt>Fix branch lengths of tree passed via -te. (-blfix)</prompt>
 <!-- 					<format>
							<language>perl</language>
							<code>($value) ? "-blfix fixbranchlengths.tre":""</code>
						</format>-->
 					</attributes>
 				</parameter>
 				
 				 <parameter type="InFile"> 
 					<name>branchlengths_tree</name>
 					<attributes>
 						<prompt>Provide a tree to fix branch lengths (-te)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code> $fix_branchlengths</code>
 						</precond>
 						<filenames>fixbranchlengths.tre</filenames>
 						<ctrls>
 							<ctrl>
 								<message>Please provide a tree for fixing branch lengths</message>
 								<language>perl</language>
 								<code>$fix_branchlengths &amp;&amp; !defined $branchlengths_tree</code>
 							</ctrl>
 						</ctrls>
 						<warns>
							<warn>
								<message>Note that your fixed tree topology file will be named fixbranchlengths.tre; your command line must include --te fixbranchlengths.tre</message>
								<language>perl</language>
								<code> defined $branchlengths_tree &amp;&amp; $specify_commandline</code>
							</warn>
						</warns>
 					</attributes>
 				</parameter>	
 				
 				 <parameter ishidden="1" type="String"> 
 					<name>branchlengths_tree2</name>
 					<attributes>
 						 <precond>
 							<language>perl</language>
 							<code>defined $branchlengths_tree &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
 							<language>perl</language>
 							<code>"-blfix -te fixbranchlengths.tre"</code>
 						</format>
 					</attributes>
 				</parameter>	
      
 <!--  -blmin   Specify minimum branch length. Default: the smaller of 0.000001 and 0.1/alignment_length. -->
 				<parameter type="Float"> 
 					<name>specify_minbranchlength</name>
 					<attributes>
 						<prompt>Specify minimum branch length. (-blmin)</prompt>
 						  <precond>
 							<language>perl</language>
 							<code> !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-blmin":""</code>
						</format>
 					</attributes>
 				</parameter>
 
 <!-- -blmax   Specify the maximum branch length. Default: 10-czbCollapse near zero branches, so that the final tree may 
               be multifurcating. This is useful for bootstrapping in the presence ofpolytomy to reduce bootstrap supports
               of short branches. -->
 				<parameter type="Float"> 
 					<name>specify_maxbranchlength</name>
 					<attributes>
 						<prompt>Specify maximum branch length. (-blmax)</prompt>
 						  <precond>
 							<language>perl</language>
 							<code> !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-blmax":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!--   -wt Turn on writing all locally optimal trees into .treels file. DEFAULT: OFF  -->				
				<parameter type="Switch"> 
 					<name>write_locally_optimal</name>
 					<attributes>
 						<prompt>Turn on writing all locally optimal trees (-wt)</prompt>
 						<format>
							<language>perl</language>
							<code>($value) ? "-wt":""</code>
						</format>
 					</attributes>
 				</parameter>
 				
<!-- -fixbr Turn on fixing branch lengths of tree passed via -t or -te. This is useful to evaluate the log-likelihood of an input tree with fixed tolopogy and branch lengths. DEFAULT: OFF  -->								
				<parameter type="Switch">
 					<name>fix_brlengths</name>
 					<attributes>
 						<prompt>Turn on fixing branch lengths of tree passed via -t or -te (-fixbr)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline &amp;&amp; (defined $tree_file1 || defined $fixed_usertree)</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-fixbr":""</code>
						</format>
						<comment>
<value> -fixbr Turn on fixing branch lengths of tree passed via -t or -te. This is useful to evaluate the log-likelihood of an input tree with fixed tolopogy and branch lengths.</value>
						</comment>
 					</attributes>
 				</parameter>
 				
 <!-- -wsr Write per-site rates to .rate file -->
				<parameter type="Switch">
					<name>per_sitefile</name>
					<attributes>
						<prompt>Write per-site rates to .rate file (-wsr)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-wsr":""</code>
						</format>
					</attributes>
				</parameter>

<!--   -wsl    Write site log-likelihoods to .sitelh file -->
				<parameter type="Switch">
					<name>per_sitewslfile</name>
					<attributes>
						<prompt>Write site log-liklihoods to .sitelh file (-wsl)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline </code>
 						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-wsl":""</code>
						</format> 
					</attributes>
				</parameter>  
  
  <!--  -wslr   Write site log-likelihoods per rate category -->
  				<parameter type="Switch">
					<name>per_sitewslrfile</name>
					<attributes>
						<prompt>Write site log-likelihoods per rate category (-wslr)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-wslr":""</code>
						</format> 
					</attributes>
				</parameter>  
  
  <!--   -wslm   Write site log-likelihoods per mixture class -->
  				<parameter type="Switch">
					<name>per_sitewslmfile</name>
					<attributes>
						<prompt> Write site log-likelihoods per mixture class (-wslm)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-wslm":""</code>
						</format> 
					</attributes>
				</parameter>  

  <!--   -wslmr   Write site log-likelihoods per mixture+rate class -->
  				<parameter type="Switch">
					<name>per_sitewslmrfile</name>
					<attributes>
						<prompt>Write site log-likelihoods per mixture+rate class (-wslmr)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-wslmr":""</code>
						</format> 
					</attributes>
				</parameter>  
				
<!--   -wspm  Write site probabilities per mixture class (-wspm)  -->
  				<parameter type="Switch">
  					<name>per_sitewspmfile</name>
					<attributes>
						<prompt>Write site probabilities per mixture class (-wspm)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-wspm":""</code>
						</format> 
					</attributes>
				</parameter>  
  
  <!--   -wspr  Write site probabilities per rate category -->
    		 	<parameter type="Switch">
    			<name>per_sitewsprfile</name>
					<attributes>
						<prompt> Write site probabilities per rate category (-wspr)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-wspr":""</code>
						</format> 
					</attributes>
				</parameter> 
  
  
  <!--  -wspmr  Write site probabilities per mixture+rate class -->
    			<parameter type="Switch">
      			<name>per_sitewspmrfile</name>
					<attributes>
						<prompt> Write site probabilities per rate category (-wspmr)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-wspmr":""</code>
						</format> 
					</attributes>
				</parameter> 
				
  <!-- -wpl  Write partition log-likelihoods to .partlh file -->
    				<parameter type="Switch">
        			<name>per_sitewplfile</name>
					<attributes>
						<prompt> Write partition log-likelihoods to .partlh file (-wpl)</prompt>
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
						<format>
							<language>perl</language>
							<code>($value ) ? "-wpl":""</code>
						</format> 
					</attributes>
				</parameter> 
 <!-- 
  -fconst f1,...,fN    Add constant patterns into alignment (N=#nstates)
  -me <epsilon>        LogL epsilon for parameter estimation (default 0.01)
  -*no-outfiles        Suppress printing output files -->
 				 				
<!-- -wsl Turn on writing site log-likelihoods to .sitelh file in TREE-PUZZLE format. Such file can then be passed on to CONSEL for further tree tests. DEFAULT: OFF  -->					
				<parameter type="Switch">
 					<name>write_sitelikelihoods</name>
 					<attributes>
 						<prompt>Write log-likelihoods in TREE-PUZZLE format (-wsl)</prompt>	
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-wsl":""</code>
						</format>
						<comment>
<value>Turn on writing site log-likelihoods to .sitelh file in TREE-PUZZLE format. Such file can then be passed on to CONSEL for further tree tests. DEFAULT: OFF </value>
						</comment>
 					</attributes>
 				</parameter>
 				
 <!-- -wslg Turn on writing site log-likelihoods per rate category. DEFAULT: OFF  -->
 				<parameter type="Switch">
 					<name>write_loglikelihoods</name>
 					<attributes>
 						<prompt>Write log-likelihoods per rate category (-wslg)</prompt>	
 						 <precond>
 							<language>perl</language>
 							<code>!$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>($value) ? "-wslg":""</code>
						</format>
						<comment>
<value>Turn on writing site log-likelihoods per rate category. DEFAULT: OFF </value>
						</comment>
 					</attributes>
 				</parameter>
 				
<!-- -fconst Specify a list of comma-separated integer numbers. The number of entries should be equal to the number of states in the model (e.g. 4 for DNA and 20 for protein). IQ-TREE will then add a number of constant sites accordingly. For example, -fconst 10,20,15,40 will add 10 constant sites of all A, 20 constant sites of all C, 15 constant sites of all G and 40 constant sites of all T into the alignment. 
 -->
  				<parameter type="InFile">
 					<name>list_csintegers</name>
 					<attributes>
 						<prompt>Specify a list of comma-separated integer numbers (-fconst)</prompt>
 						<filenames>integerfile.csv</filenames>	
						<warns>
							<warn>
								<message>Note that your list of comma-separated integer number file will be named integerfile.csv; your command line must include -fconst integerfile.csv</message>
								<language>perl</language>
								<code> defined $list_csintegers &amp;&amp; $specify_commandline</code>
							</warn>
						</warns>
						<comment>
<value>Specify a list of comma-separated integer numbers. The number of entries should be equal to the number of states in the model (e.g. 4 for DNA and 20 for protein). IQ-TREE will then add a number of constant sites accordingly. For example, -fconst 10,20,15,40 will add 10 constant sites of all A, 20 constant sites of all C, 15 constant sites of all G and 40 constant sites of all T into the alignment.</value>
						</comment>
 					</attributes>
 				</parameter>
 				
 				<parameter ishidden="1" type="String">
 					<name>list_csintegers2</name>
 					<attributes>
 						 <precond>
 							<language>perl</language>
 							<code>defined $list_csintegers &amp;&amp; !$specify_commandline</code>
 						</precond>
 						<format>
							<language>perl</language>
							<code>"-fconst integerfile.csv"</code>
						</format>
 					</attributes>
 				</parameter>
 						
		</parameters>			
 	</paragraph>				
 </parameter>

<parameter type="Results">
	<name>results</name>
	<attributes>
		<filenames>*</filenames>
	</attributes>
</parameter>

</parameters>
</pise>


