TNT stands for "Tree Analysis Using New Technology". It is a parsimony phylogenetics program that allows very fast searches of huge numbers of cladograms.

I (Nick Matzke) am currently working on an R package I am calling TNTR. It will include basic functions for reading/writing data and trees from R to TNT, and parsing the TNT outputs. Although I am really a Bayesian, when working with morphology datasets and their various coding issues, it can be extremely useful to quickly estimate parsimony trees. Examples include: finding coding mistakes, finding starting trees, and finding parts of the tree with no morphological support at all. And, parsimony is an important way to "look at what the character data are doing", which is easily lost in complex Bayesian analyses.

Unfortunately, TNTwiki — the old help wiki (original / Wayback Machine partial archive) — has apparently permanently died. This is something of a crisis for anyone less than an expert user, as the TNT command structure is very obscure, and the wiki was almost the only online help. I will attempt to re-create the basics of the help at TNTwiki. Feel free to add to it (you may have to email me to get access to PhyloWiki).

Another problem was the loss of many of the TNT scripts found in the TNT script archive. Many of them were used in publications that referred to TNTwiki as the permanent archive. I am attempting to repair this in TNT scripts, below.

(Please send me scripts if you find missing ones, or if you have new ones you would like to archive. This wiki is hosted by wikidot, a major wiki server, and it is a free Educational-Resource account, so it should be pretty permanent. Remember, if you post scripts, (a) other people might use them and cite you, and (b) more importantly, you will be able to find it yourself when you've moved computers 5 years from now.)

Other sources of TNT help:

List of TNT command-line commands

(link to this section)

For help on command "xxxx" enter "help xxxx" 
For help on ALL commands, enter "help*" 
For help with scripting language, enter "help+" 
Enter "help [ topic ]" for possible help topics.

     agroup   alltrees  ancstates        apo     bbreak       beep       best 
    bground    blength     blocks      break   bsupport      ccode       cdir 
     change   chkmoves      chomo      ckeep        cls   clbuffer     cnames 
   collapse    comcomp   condense  constrain      costs    cscores     cstree 
     dmerge      drift       edit       echo     export        fit   fillsank 
      force   freqdifs       help       hold     hybrid      ienum    incltax 
       info   lintrees        log       keep     length      lmark  lmrealign 
     lquote   majority        map     minmax   mixtrees       mono        mrp 
       mult      mxram     mxproc      naked     nelsen    nstates   outgroup 
  procedure      pause   pcrprune      pfijo       piwe    pruncom  prunmajor 
 prunnelsen    pruntax       ptnt  qcollapse    qnelsen      quote       quit 
  randtrees    ratchet     rcompl       rdir    rebuild     recons     report 
     reroot   resample     resols     rfreqs     riddup      rseed        run 
       save     screen     scores    shpcomp    sectsch  shortread     silent 
      slfwt  slaveproc    smatrix       sort    sprdiff     subopt      svtxt 
     system     tables     tagset    taxcode  taxlabels   taxonomy    taxname 
    tchoose      tcomp     tequal      tfuse     tgroup     thanks    timeout 
     tnodes      tplot      tread      tsave    tshrink      tsize      ttags 
    txtsize      tzert       view   vversion       warn      watch      xcomp 
     xgroup     xinact      xmult      xperm      xpiwe      xread      xwipe                                                                          
     unique   unshared   usminmax        zzz

The file tnt.htm from the TNT download

(link to this section)

This "tnt.htm" file is included in the TNT download. It is a help file, but incomplete by itself; but it can help on some issues, so it might as well be in put online for google-tasticness. I have put the text here: tnt_htm

See the original file, inside the download, for original formatting etc.


TNT scripts

(link to this section)

Some other scripts are available in the TNT download, also here: . A link to the same (I think; it doesn't load for me at the moment) is/was

I have uploaded them here as a backup, quoting whatever description/authorship was available in the script.

See also: General_Documentation.pdf, for general documentation on TNT scripting.

title usage/function/purpose script file(right-click, save as)
Bremer support Calculates Bremer support. Easy to use given its nice interactive window.
Partitioned Bremer support Calculates partitioned Bremer support. By Carlos Peña.
aquickie A script to perform a simple one-shot analysis, ideal for new or lazy TNT users . This runs a simple analysis with a search for most parsimonious trees (or asks whether you want to do a consensus estimation, if the data set is large), then calculates group supports using resampling.
stats Calculates RI and CI. [NOTE added by Nick Matzke: seems to crash if you have more than about 400 trees in memory. i.e. after "hold 400; mult 100 =tbr drift ;" works, but after "hold 500;" it doesn't.]
TTS Calculates the number of three-taxon statements implied by the first tree that are true on the second tree.
Term lengths This script finds the taxa which increase tree length the most (reporting ties when they exist).
RF_Distances This script calculates the Robinson-Foulds distance between two trees given as arguments
Implied_weighting This script defines a (user-defined) number of K, under implied weighting (IW), that produce even intervals of fit/distortions, analyzes the matrix under IW using these values of K, and make some comparisons between the results obtained under different K-values (to evaluate stability of results across evenly differing analytical conditions). More details in Mirande (2009)
LandschW This script allows to run searches considering (exclusively) landmark data. It generates a Wagner tree (RAS) and swaps it using TBR. It receives only one argument, that is the level of thoroughness of the analysis ( 0 is the lowest, 4 is the highest). If no argument is given the script will run a seach departing from a single Wagner tree and considering the current settings for landmark optimization. (This scripts replaces the original script where each run departed for a random tree)
Landcombsch This script allows running tree searches combining landmark data with other sources of evidence. Each replicate starts from a Wagner tree (RAS)followed by TBR. Only a single optimal tree is kept in memory. You should specify one argument: 1st = strength of the search (modifies the number of replicates and precision in landmark optimization(0: lowest (fast) , 4: highest (slow). Default = 0)
export_tps This script export to TPS format the landmark coordinates of terminals and inner nodes of the first tree in memory. It produces one file for each lm configuration. Besides it generates a tree drawing with the numbers of the inner nodes corresponding to the names given in the TPS file
mytaxo This is the script used in Goloboff et al., 2009. See paper for details of usage. The script checks groups (calculating their fit on multiple trees), also finding taxa to prune to improve groups. First argument is max. depht, second argument is group to improve (both are optional). It stores taxa to prune in group 31 (if doing only a group, it stores taxa to cut to improve that group, to the level specified)
colorgroups This is the script used in Goloboff et al., 2009. The script (for Windows only) will take a list of taxa and automatically produce color diagrams displaying the groups. If you wish to use the same color code for several separate groups, you can separate the groups to be given similar color with a plus and a colon, and the groups to be given different colors with blank spaces; for example: colorgroups _Araneae_+:_Nematoda_ _Diptera_+:_Porifera_ will give spiders and nematodes one color, and sponges and flies another. The figures produced with this script can be exported as metafiles.
blens This macro plots phylograms
dohi This is the script used in Goloboff et al., 2009. It takes as argument the name of a group, so that: dohi _Mammalia_ will find the group in the tree most similar to "Mammalia", and display it on screen (counting the number of non-members included, and of members excluded).
blockboot performs Siddall's (2010) partition bootstrap
blockjak performs Siddall's (2010) partition jackknife
Codonweight allows reweighting of 1st, 2nd and 3rd positions for a scope of characters
ILD Incongruence Length Difference Test of Farris et al 1995
deactmiss Deactivate taxa with a given amount of missing data
excludemiss Excludes characters that are missing for a given percentage of taxa
forall Finds all files (recursively traveling subdirectories) which match a file name.
example An example script/template that can be copy pasted for other scripts presented here. none
(NEW) templetontest "This TNT script implements the Templeton Test from: Templeton AR 1983, Evolution 37(2): 221-244" — by Alexander Schmidt-Lebuhn. See script for further notes.
(NEW) Incongruence Length-Difference (ILD) test Ross Mounce contributes two versions of the ILD script. For further notes see this discussion thread on the TNT Google Group.,
(NEW) "This script calculates the modified MSM (MSM*, Manhattan Stratigraphic Measure; Pol and Norell, 2001) and GER (Gap Excess Ratio) Wills, 1999) on the trees in memory using the Sankoff age character (detailed in file dataMSM.TNT)." See script for further notes. Example files (for dataMSM.TNT etc.) are available in the zipfiles for Pol and Norell 2001, Pol and Norell 2006, which I have attached.

Here are the additional scripts from the TNT download.

Original source:

title usage/function/purpose script file(right-click, save as) "This script contains instructions to run very large data sets." "Please note !! There is an update for this script: . That script is better at handling large data sets with very numerous reconstructions (and can also save the arrays of increments/decrements to a file, so that testing with different options can be done without having to generate again all possible reconstructions for each of the characters). It requires a version of TNT for March, 2010, or later. The present script is this note aside exactly the same one as used by Giannini & Goloboff (2010), and is preserved as such for documentation purposes." "This scripts merges two trees (mixing groups of as even a size as possible). Must specify two trees to use as source for new tree." "This is a very simple search routine, which takes a tree (given as first argument) and starts TBR swapping from it. This saves a single tree. If implied weighting is on, or discrete characters are included, that should work ok. Note that the settings for landmark optimization (determined with the "lmark" command, see "help lmark;") are those at the time of calling the file." "This script merges tags in two files. Each of the files must contain tags in parenthetical notation (saved with 'save*.,'). Must give name of files to merge as arguments. The labels for both trees are shown, separated by a slash., note that the labels are inverted (first label shown corresponds to second tree). The second tree is plotted., when the second tree has a group not present in the first, the second label (corresponding to first tree) is indicated as '?'." "This script first calculates strict consensus for the entire data set, and then calculates the bremer support for each partition of the data set. You have to give the name of the data set as argument. Once the script finishes running (it may take a while), then you process the results by calling (on the Windows version) the file The search is sufficient for a data set with 300-500 taxa., change it in case you feel the search is inadequate!" "[T]his script processes results produced by the script —it shows the bremer supports for each group in the consensus, for each partition, in a friendly way. Before running this script, you have to run, place all the resulting files in the current folder, read the data set (make sure you make space for long taxon names), and call this script." Sectorial bootstrap, run in parallel? "Five arguments and a preexisting tree (in parenthetical notation) needed for this script: 1 - data set (name only, extension must be '.tnt'). Tree file *must* have the same name, but extension '.tre' (iif there are multiple trees, tree 0 will be used. Results are saved to file with the same name, but extension '.sup'. 2 - nchunks in parallel 3 - number of cycles in parallel 4 - nchunks in first round of parallel 5 - nchunks in last round of parallel" Sectorial bootstrap, run serially? "This script runs (serially) a sectorial approximmation [sic] of supports, for large data sets. It automatically breaks the tree in chunks of 200-166 nodes. The groups are those in a tree found by a quick search (see below). You have to give the name of the data set as first argument (name only, extension *must* be '.tnt'). Results are written to screen (or log file, iif opened before running this routine), and saved to a file with the same name as the data set but extension '.sup'." "This macro performs the support weighting of Farris (2001)" "This script finds the taxa which increase tree length the most (reporting ties when they exist). You must specify which tree to use (as first arg.)" "A simple macro to transform a TNT tree into a vectorial graphic (SVG). [I]t can be read with any web browser (except… that one) (written by J. Salvador Arias, 2010)" "This script is a refinement of the original script of Giannini & Goloboff (2010), It is intended for use in large data sets where there are too many reconstructions to be handled by the original script. This version also adds the option of saving the reconstructions for later use (so that they do not have to be generated again), and the option of using fewer significant digits and/or averages for the terminal taxa (which may speed up enumeration of reconstructions). The original script is retained for documentation purposes." "This macro repeats the xmult command, fusing with previous results every time."

Help on each TNT command

(link to this section)

    define groups of taxa.  Syntax is as in "tgroup" (but options 
    "len", "nod", "siz", or "mono" not allowed, and  
    "agroup !;" saves only active taxa). 

    generate all trees for active taxa 

    N   define character(s) N as ancestral. Ancestral 
        states correspond to those of current outgroup 

    N     plot synapomorphies for tree(s) N 
    [N    plot synapomorphies common to tree(s) N 
    -     list instead of plotting on tree 
    [-N/L list synapomorphies common to tree(s) N, node(s) L 

    Perform branch-swapping, using pre-existing trees as starting point. 
    Use "bbreak=options;" (change settings and run) or "bbreak:options;" 
    (change settings, don't run).  This swaps according to current settings 
    of suboptimal, constraints, and collapsing. 

    Basic options are: 
      tbr         use TBR 
      spr         use SPR 
     [no]fillonly swap until tree-buffer is filled, and then stop. 
     [no]mulpars  save multiple trees. 

    Fine-tuning options are: 
     [no]safe     The "safe" option uses a slower (but safer) method for 
                  updating buffers when finding a better tree under TBR 
                  (default is "nosafe"). 
     [no]skipspr skips the SPR phase on a single tree when doing multiple 
                  RAS+TBR saving several trees per replication; "skipspr" 
                  is useful in conjunction with "nosafe", but not so much 
                  with "safe" because then the initial portion of TBR 
                  (when better trees are being found often) gets slowed down 
                  and SPR doesn't.  The "nosafe" option only makes a  
                  difference for very large data sets; note that "skipspr" 
                  modifies the behaviour of both "mult" and "xmult". 
     [no]int N    There are two options, "int 1" and "int 2" (both options 
                  identify most relevant characters for a series of swaps, 
                  option 2 also reorders characters to try to save time). 
                  These options useful only for large matrices (>10,000) with 
                  large numbers of characters; otherwise they tend to produce 
                  slower swapping. 
     [no]randclip randomize clipping sequence (with current random seed). 
     [no]xbit     On 64-bit systems, the (default) "xbit" option turns on 
                  optimization using 64 bits, when possible.  This tends to  
                  be 20-25% faster. 
     [no]preproc  with "preproc" the program tries to identify and effect 
                   first the clippings that would improve the tree the most; 
                  this has effect only on "mult" searches with hold=1 (and 
                  only when skipping the SPR phase), and TBR swapping from  
                  existing trees with mulpars off.  This may save a little  
                  time in the initial stages of the search for very large 
                  data sets, although the end gain is small. 
     clusters N   use node-clusters of N nodes.  As the data set becomes  
                  larger, clusters of more nodes produce faster TBR-swapping. 
                  When using clusters also for wagner trees, the same size as 
                  defined here is used. 

    =   beep on errors and warning messages 
    -   don't (default) 

    filter trees, discarding suboptimal 
    N   keep trees up to N steps (weighted) worse than best 
    -   invert the selection criterion 
    [   discard trees not fulfilling constraints of monophyly 
    ]   discard trees fulfilling them 
    *   collapse the trees before comparing 

    as first argument when calling TNT, it tells it to run in background.

    Files recognized while in background:

      stop_tnt_PID     if file exists, interrupts (as if pressing <esc>). 
                       Note that if program is in a "wait" loop, then this 
                       (just like <esc>) interrupts the wait and programs  
                       continues with instructions subsequent to the "wait" 
                       (unless "execute_tnt_PID" exists, case in which, 
                       TNT switches immediately to that file).  Thus, if the 
                       program is in a "wait" loop, stop_tnt_PID may have 
                       to be created a second time for immediate exit.

      pause_tnt_PID    if file exists, TNT is paused (as if pressing "p"). 
                       When TNT paused, removing file resumes work.

      execute_tnt_PID  when TNT finishes current set of instructions (or 
                       when interrupted with stop_tnt_PID), uses contents 
                       of file as new set of instructions (moving already 
                       executed instructions to file ".tntexec_N_PID", where 
                       N increases as TNT continues being reset). This is 
                       not recognized by slaves, and works only after normal 
                       termination (if in backgrond, errors cause an exit).

    Except for "execute_tnt_PID", file contents are irrelevant; TNT only 
    checks existence of the file itself. 

    N;    show table with branch lengths for tree(s) N 
    *N;   same, using a tree diagram 
    > N/L for continuous characters, show maximum increase in value 
          for each branch, for tree(s) N, char(s) L.  If a branch  
          always decreases, show minimum decrease.  From command  
          line, '[' can be used instead; this can be used together 
          with '<' (see below) 
    < N/L for continuous characters, show maximum decrease, as for '>'.  
          If a branch always increases, show minimum increase. From 
          command line, ']' can be used instead. 

    J K L   Define blocks to start at character(s) J K L 
    ;       Show current blocks 
    *;      Save curent blocks 
    = J K   deactivate all characters and taxa not in blocks  
            J K (if list preceded by "&", only shared taxa 
            remain active) 

    =   enable breaks with <esc>, pauses with 'p' (default). During 
        searches, pressing 'm' will stop the search and move on 
        (executing the rest of commands from file or console). 
    -   don't 
    /   copy text (ending with semicolon) to display as warning if 
        calculations are interrupted ("yes" interrupts anyway) 
        By default, interruption produces no queries 

    Calculate bremer supports, using trees currently in memory.

    N/L   use tree(s) N, pruning taxon (taxa) L, and display results

    Other options:

      =N    collapse groups with support < N 
      *     save tree as last tree in memory 
      [     use relative (instead of absolute) supports 
      ]     use relative supports, using only trees within absolute support 
      !N    calculate supports by TBR-swapping, for groups in tree N.  If 
            N preceded by '+' then it adds to the cost of loosing a group 
            in a tree the score-difference for the tree itself (=more 
            accurate; default is more conservative).  Using '!!' instead 
            of just '!', no groups in reference tree are collapsed. 
      &X    combine absolute (A) and relative (R) bremer supports, 
            to approximmate results of resampling with P(del)=X, with 
            Comb = ( R x (1-X) ) ^ ( 1/A ). 

    !  re-sets ccode to the one defined in the data file 
    Other than that, sets character codes.  Specifiers are: 
         +   make following character(s) additive (this means "ordered", Goloboff et al. 2008 p. 7 -- NJM)
         -     "      "         "        non-additive (this means "unordered", Goloboff et al. 2008 p. 7 -- NJM)
         [     "      "         "        active 
         ]     "      "         "        inactive 
         (     "      "         "        Sankoff 
         )     "      "         "        non-Sankoff 
         /N   apply weight N to following character(s) 
         =N   apply N additional steps to following character(s) 

       change directory 

    L/N/X Y ;   report min-max. changes from state(s) X to state(s) Y 
                for tree(s) L, char(s). N.  Can use names or numbers, and 
                enclose multiple states/names in brackets. From 01 to 23 
                counts all changes from either 0 or 1 to either 2 or 3. 
    [ L/N/X Y   same, but displays min/max. changes tree by tree 
    ] L/N/X Y   same, but displays results character by character 

    Check moves that produce trees of equal score (or within specified 
    suboptimal difference), and report number of moves for each node. 
    This helps to quickly identify taxa that decrease resolution of the 
    consensus (or supports). 
         [    sort by distance, instead of number of moves 
         &    sort by rerooting depth 
         *    don't list or sort, just show moves on tree diagram 
    Options [, & or * can be followed by list of trees to process 
    (default=all), and this can be followed by the minimum value to 
    report (as /N; this is optional; default minimum is 1).  The 
    list (or the specification for the minimum value) can be followed 
    by ">N" (or "<N"), where N is the number of group to which 
    the taxa with value equal or greater than the minimum will be  
    added (or removed from).  In the case of internal nodes, all the 
    descendants of the node are added to (removed from) the group  
    specified. Note that when sorting by rerooting depth, the taxa  
    that belong to the rerooted clade are added/removed.  If macro 
    is ON, then using "=A" will store in array of name/number A, 
    the number/distance/depth for each node of the tree (a single tree 
    must be specified in this case); this can be used together with  
    ">N" or "<N". 

    N   show homoplasy (=extra steps) for tree(s) N 

         set current ccode as default 

    Clear screen 

    ;      clear text buffer 
    *     clear command buffer 

    Name character(s) / state(s):  
        {N1 charname state0 state1 state2 ... n ;  
        {N2 charname state0 state1 state2 ... n ;  
        {N3 charname state0 state1 state2 ... n ;  
      *;   save character names 
      !;   save character names (active chars. only) 
      +N   rename char. N: charname state0 ... n 

    N;   set level of tree-collapsing to N 
           0   no collapsing 
           1   if some optimization implies support, keep branch ("rule 3") 
               (this is the default in PAUP*) 
           2   if ancestor and descendant state sets differ, keep branch 
               (this is equivalent to "amb-" of Nona/Pee-Wee) 
           3   collapse branch if some optimization lacks support 
               (this is the default of Nona/Pee-Wee: "rule 1") 
           4   rule 4 of Coddington and Scharff 
           5   Collapse using SPR 
           6   Collapse using TBR 
    +    collapse trees temporarily for consensus calculations (default) 
    -    don't 
    [    after a search, automatically condense trees 
    ]    don't ( default) 
    Alternatively, the options can be given as strings: none, rule 1, amb, 
    rule 3, rule 4 , spr, tbr, [no]auto, [no]tempcollapse. 

    Calculate combinable component (=Bremer ) consensus tree 
    N/L    display consensus for tree(s) N, excluding taxon (taxa) L 
    *N/L   same, but keep consensus as last tree in memory 

    N    collapse branches for tree(s) N, according to settings of "collapse". 
    [N   same, reinforcing constraints of monophyly (i.e. keeping constrained 
         groups, even if unsupported). 
    N/L  collapse branches for tree(s) N, ignoring taxa L. 
    /T N collapse set of node(s) N, for tree T.  Using "*" instead of T, 
         it collapses nodes of tag-tree (retaining the rest of labels); if 
         "=xxx;" is used instead of a node list, then it collapses all 
         the internal nodes labeled as "xxx". 

    =   Re-inforce constraints for mono- and non-monophyly 
    -   don't (default) 

    N = x>y z   Define transformation costs for character(s) N to be z from all 
                states in x to all states in y.  Can use square brackets to 
                enclose multiple states (e.g. [012]>3 is from either 0 or 1 or 
                2 to 3).  Using / instead of > defines costs as symmetrical. 
                The symbol ? means every possible state. 
      *;          save all costs. 
      -;          save costs, for active chars. only. 
      [;          save costs in TNT format (default) 
      ];          save costs in SPA format 
      <;          don't allow using sankoff (saves small amount of memory) 
      >;          allow using it (=default) 

    N/L   report length/fit for character(s) L on tree(s) N 
    !N/L  same, optimizing polytomies as "soft" 

    N = [cst]  read character state tree (=costs) for char(s) N. 
               Type cst after a carriage return, with symbols /\-| and X. 
    +;         optimize character state trees by decomposing them in binary 
               variables; this is faster, and means that under implied weights 
               the fit for the character is the sum of the fits of the  
               individual variables. 
    -;         optimize character state trees as wholes; under implied weights, 
               the fit for the character is calculated using the homoplasy for 
               the entire character, which may differ from the "+" option. 

    dmerge OUT =DIR IN1 IN2    merges files in1 and in2 (from directory dir) 
    dmerge*;     merges characters with identical names 

    Do tree-drifting, from trees in memory.  Options are: 
      iterations         number of cycles (=iterations) to do 
      numsubs N          number of replacements (i.e. accepted tree 
                         rearrangements) to do in perturbation phase 
      xfactor            makes acceptance of suboptimal trees less likely 
      [no]autoconst N    number of constrained cycles 
      [no]giveup N       max. percentage of full swap to do in perturbation 
                         phase.  This is an int, so 99 means don't give up 
      fitdiff            max. difference in absolute fit 
      rfitdiff           max. difference in relative fit 
      findscore N        stop drifting when score N hit 
      [no]equals         alternate perturbed and unperturbed drift cycles 
      [no]fuse NxR       every N iterations, do R rounds of fusing to the 
                         N trees 
      [no]dumpfuse       if fusing fails to produce a better tree, [don't] 
                         dump all the suboptimal trees 
      flat N             run the first N iterations using the relative 
                         fit difference defined with rflat 
      rflat N            max. difference in relative fit difference  
                         for initial iterations 
      flatnumsubs N      number of replacements to do for initial iterations 
      [no]pert           never accept suboptimal rearrangements (i.e. "drift" 
                         only wanders around in the island) 
    Options set with "drift:[options];" or "drift=[options];" (first case 
    case changes settings only, second case runs). Using "drift:;" current 
    settings are displayed 

    X Y   edit node Y of tree X.  Then, J L sends J to node L.  If J is an  
          an ancestor of L, reroots clade J on L. /N collapses node N (this 
          can be given as a list, with nodes separated by '+'). 

    =   echo each command 
    -   don't echo 
    [   if log file opened and taking commands from console, 
        echo console input to log file 
    ]   don't 

    export data in NEXUS format.  If filename followed by "+", 
    copies everything to the end of the NEXUS file, until a semi- 
    colon is found (use it to embedd PAUP* or TNT commands in 
    the file).  TNT commands can be included at the end of the 
    file, preceded by "begin tnt." 
    Possible arguments (before file name): 
        *    trees as well 
        +    step-matrices as well 
        -    trees only (including tree-tags, if defined) 
        >    tree-tags only, as branch lengths 
        <    tree-tags only, as branch labels 
        [    save as dna 
        ]    save as standard 
        !    save as Fasta instead of Nexus (!! skips gaps) 

    N   report total fit, for tree(s) N.  It is measured with a convex 
        increasing function, to be minimized 
    !N  same, optimizing polytomies as "soft" 
    *N  report total fit (measured with a concave decreasing function, to  
        be maximized; the equivalent of what PAUP* and Pee-Wee report) 

    =   complete polymorphic cells for Sankoff characters 
    -   don't (default) 

    ;   report present constraints 
    ]   de-activate constraints 
    =   followed by a tree, use groups in tree (&N uses tree N) 
    /   followed by a tree, use tree as skeleton tree (&N uses tree N) 
        (if outgroup is excluded, it acts as a "convexity" constraint) 
    :   same as /, but for negative constraints 
    +   positive constraints: [ a b c  (d e) ] ( taxa d and e float; 
        if outgroup is floating, acts as a "convexity" constraint) 
    -   same as +, but negative 
    >N  taxon(taxa) N floating for all positive constraints 
    <N  same, for all negative constraints 
    *   report number corresponding to each constraint 

    Calculate frequency difference tree (FDT) 
    =N      use N as cutoff 
    N/L     display FDT for tree(s) N, excluding taxon (taxa) L 
    [J]N/L  calculate frequency differences for each group of 
            tree J, on tree(s) N, pruning taxon (taxa) L 
    (J)N/L  same, but display results as table 
    *N/L    same, but keep FDT as last tree in memory 

    ;     display list of commands 
    *     display options for all commands 
    xxx   display options for command xxx (equivalent to xxx ?) 

    N   set tree buffer to keep up to N trees 
    +N  increase max. trees to number of trees in memory + N (++ = 1 ) 
    -N  decrease max. trees to number of trees in memory - N (-- = 1 ) 

    hybridize/complete trees.  This exchanges non-identical groups 
    pruning unshared taxa, so that resulting tree is incomplete. 
    This is meant to be used in cases where tree-fusing (which 
    exchanges only identical groups) cannot improve the tree, 
    by virtue of the trees being too different (i.e. very poorly 
    structured data), but it outperforms tree-fusing rarely. 
    X Y/Z   exchange a chunk (with no more than Z unshared taxa) 
            between trees X and Y, then complete trees and swap. 
            Note that X Y may be a scope (or a tree-group) containing 
            two trees. 
    -X Y/Z  same, but don't complete or swap trees 
    +N      if tree N is incomplete, sequentially add missing taxa 
    *N      same, but also swap (TBR, nomulpars) 

    Do implicit enumeration (=results guaranteed to be optimal; 
    feasible only for small data sets) 
       &      when there are N most parsimonious trees, but maxtrees 
              is set to a smaller number, take a (pseudo)random sample 
              of the N trees, such that each tree has a prob. of about 
              maxtrees/N to be sampled. Works better as maxtrees/N is 
              closer to 1. 
       -      deactivate a bounding method speeding up many well- 
              structured data sets (usually produces slower searches) 

    [N   report which taxa are included in tree(s) N (default) 
    ]N   report which taxa are excluded from tree(s) N 

    +   report which character(s) are informative (default) 
    -     "      "        "       are uninformative 

    =    draw trees in Linux format (default) 
    -    don't 
    *    use command-recalling 

    xxx   open log file xxx (use "stdout" if redirecting output) 
    +xxx   open in append mode 
    /     close current log file 

    N   keep no more than N trees, discard the rest 

    N   report total length, for tree(s) N 
    !N  same, optimizing polytomies as "soft" 

    Map and handle settings for 2D and 3D data (landmarks) 
      ambig         specify which points to choose in the case of ambiguity  
                    (rarely needed, as ambiguity is uncommon).  Examples:  
                       ambig YxZ C  chooses maximum y first, if ambiguity 
                                    remains minimum x, and if ambiguity remains 
                                    maximum z (ambiguities in unspecified 
                                    coordinates are solved randomly), for 
                                    character(s) C. 
                       ambig * C    choose randomly. 
                       ambig ;      display current setting. 
      cells N       divide grid in N cells 
      connect       define connections between points for display (windows only) 
      factors       define factors for the individual landmarks.  These are then 
                    used *instead* of the factors determined automatically. 
                    Syntax is:  factors =F C/L, which uses factor F for character(s) 
                    C, landmark(s) L (if no C or L specified, it's all C or L;  
                    if F is "*" then automatic factors are used for C/L). 
                    Note: factors are used only when implied weighting is off! 
                    With implied weighting OFF, factors multiply the score. 
                    With implied weighting ON, factors are always unity. 
     [no]gwts       set type of implied weighting to [not] global.  Global calculates 
                    the score by summing the steps beyond minimum, for all landmarks 
                    in the character.  Non-global calculates the score for a character 
                    with N landmarks using the steps beyond minimum for each landmark 
                    and dividing by 1/N. Score is always E/(K+E), where E = steps 
                    beyond minimum, and K = concavity constant.  See also below,  
                    under "usmin". 
     [no]inscale   [don't] weight individual landmarks so that the contribution 
                    of each landmark within a character is similar (i.e. give 
                    landmarks with a larger range a lower weight) (default = don't). 
                    Note that any of the two choices makes the contribution of a 
                    landmark character (unless modified with "lmark wts") similar 
                    to that of a step in a discrete character, by weighting based 
                    on the range of the landmarks and the number of landmarks. 
     [no]iter       in addition to sankoff approximmation, iterate exact calculation 
                    of geometric medians.  For dichotomies, this uses an exact 
                    solution for the Fermat point (ancestor-left-right descendant), 
                    with functions written by S. Catalano with collaboration from 
                    P. Goloboff.  For polytomies, a heuristic approximmation of 
                    the geometric median is used. 
      list          list character types.  Default is listing dimensionality of 
                    each character.  List - lists only one-dimensional characters; 
                    list + does the opossite; list N lists all characters of N 
     [no]lowmem     use low memory calculations (possibly slower) 
      lscores N/C/L report individual landmark scores in tree(s) N, character(s) 
                    C, landmark(s) L (default=all). 
      map N/C       map character(s) C on tree(s) N 
      maxiters N C  iterate up to N times, cut when improvement below C 
      maxprec N     skip characters with range (max. dist) below N 
      multimap      show ambiguity in point mapping.  Syntax is :  
                        multimap R T C L 
                    where R=replications, T=tree, C=character, and L=landmark. 
                    Variability indicates either ambiguity in optimization (if 
                    settings exhaustive) or errors in optimization algorithms 
                    (if settings superficial). 
      nest N W      nest sankoff approximmation N times, with a Window of W cells 
      option        display all current settings for landmark optimization 
      precision     report expected precision of individual points under sankoff 
      rescale       multiply each value by a factor.  Note this modifies the matrix 
                    in memory.  Syntax is:  
                        rescale =F C/L  
                    where F=factor (if F is "*", then it uses current factors for 
                    each landmark), C=character(s), L=landmark(s). 
      shake N       in first sankoff approximmation, slightly distort grid N times 
     [no]showhtus  [don't] show HTU's coordinates after mapping (default = don't) 
     [no]shrink     shrink grid if there are outliers (useful for low cell values, 
                    8 or less, probably won't help for cells > 10). 
      swap XY       swap values of XY (or XZ, YZ) 
     [no]skip       during the first sankoff approximmation, try to quickly identify 
                    cells not needed (may save some time). 
     [no]termpoints make sure the first Sankoff matrix contains terminal points. 
                    With "termpoints -" no grid is used, only the points of terminal 
                    taxa; "termpoints +" reconnects the use of grid. 
      usmin         set (or display) current minima for implied weighting.  Default 
                    is maximum span of Steiner tree for any triplet of taxa.  This 
                    quickly sets an upper bound for the actual minimum, but may 
                    overestimate it.  The user can set a different value (e.g. with a 
                    search for each individual landmark.  Syntax is: 
                        usmin =M C/L  
                    where M=minimum (if M is "*", then it uses default), C=character(s),  
      wts           define weights for the individual landmarks.  These are then 
                    *combined* with the factors determined automatically. 
                    Syntax is:  wts =W C/L   which gives weight W to character(s) 
                    C, landmark(s) L (if no C or L specified, it's all C or L;  
                    if W is "*" then unit weights are used for C/L). 
                    Note: landmark wts cannot be used with implied weighting and 
                    "gwts" (they are just ignored). 

    Realign specified landmark configurations (=characters) 
    Keep in mind that the realignment modifies the matrix held in memory, 
    so that it is not possible to go back to the original coordinates 
    except by re-reading the data file. 
    Twopoint (p1 p2)/C  align character(s) C using baseline registration considering  
                        landmarks p1 and p2 as reference. Valid only for 2D  
    Rftra  [N]/C        align character(s) C in all taxa against taxon N using a  
                        repeated medians procedure (Siegel & Benson 1982). Valid only 
                        for 2D characters. 
    Pairlin [N]/C       align character(s) C in all taxa against taxon N minimizing 
                        the sum of linear distances. 
    Tree T cycles Y level L/C  align character C on tree T using a tree-based alignment with  
                        parsimony as optimality criterion (Catalano & Goloboff in press) 
                        Y= number of cycles of improvement/perturbation   
                        L= thoroughness in improvement step (0-4)   
                        Currently implemented for 2D landmarks. Working on 3D implementation. 
    Random N            rotate/traslate all configurations at random. Does N cycles of random 
                        changes to  the alignment.  Useful for exploring the  data and the  
                        effectiveness of alignment algorithms. 
        !               Adjust size (Option valid only for Rftra and Pairlin) 
    NOTE: the code for aligning was written by Santiago A. Catalano in collaboration 
    with P. Goloboff. 

    =      set literal quotes on (see "quote") 
    -      set literal quotes off (see "quote") 
    [      within "quote" read &N as ASCII character N 
    ]      don't 

    Calculate majority rule tree (MRT) 
    =N       use N as cutoff 
    N/L      display MRT for tree(s) N, excluding taxon (taxa) L 
    [J]N/L   calculate frequencies for each group of tree J, 
              on tree(s) N, pruning taxon (taxa) L 
    (J)N/L   same, but display results as table 
    *N/L     same, but keep MRT as last tree in memory 

    N/L    map character(s) L on tree(s) N 
    -      show optimization for character(s) L on tree(s) N, as a text list 
    :      show down-pass state sets instead of final 
    [      state super-sets for character(s) L on consensus for tree(s) N 

    ;    show minimum-maximum possible steps for each (active) character 
    -    same, considering only active taxa 
    *    combine minimum/maximum in a single table 
    +    show minimum-maximum for continuous character(s) 

    N/L    combine trees N (with different sets of taxa), excluding taxon 
           (taxa) L.  Combines only uncontradicted groups. Using =J it does  
           J different input orders.  Using =[J k] it recalculates consensus 
           every k randomizations, until stability is reached J times. 
    *N/L   save the tree as last memory tree ( default = show) 

    N    check whether tree(s) N satisfy constraints 
    -N   check whether tree(s) N violate constraints 
    *    same, but reporting group by group 

    Create matrix representing trees in memory 

    do N random addition sequences, followed by rearrangements. 
    Options are: 
      wagner       no branch-swapping 
      spr          use SPR branch swapping 
      tbr          use TBR branch swapping 
      [no]keepall  keep the trees from all replications 
      replic N     do N replications  
      hold N       save up to N trees per replication (only if swapping) 
      [no]ratchet  do ratchet as well (settings with "ratchet" command) 
      [no]drift    do drift as well (settings with "drift" command) 
      [no]wclus N  after adding N taxa to the wagner tree, start using 
                   node clusters (of size defined with "bbreak:clus SIZE"). 
                   Useful only for very large data sets (several K-taxa). 
      outfreq N    frequency for which reports are produced during branch 
                   swapping (default is every N=10 clips, but for large data 
                   sets this implies reports take too long to be produced). 
      ras          use randomized addition sequences for Wagner trees  
                   [default, works best for most data sets] 
      cas N        use closest-addition sequence for Wagner trees (ties in 
                   the addition sequence broken randomly), looking ahead up 
                   N taxa (no N = all taxa). Tends to work best on data sets 
                   with a lot of incongruence. 
      fas N        as previous one, but using furthest addition sequence 
      ias N        as previous one, but select first those taxa which make 
                   the largest number of characters informative (N.B. only  
                   additive/nonadditive characters considered for this; the 
                   other character types have no influence on the sequence). 
                   Tends to work best on data sets with many missing entries 
                   and non-overlapping blocks of data. 
      sas N        as previous one, but select first those taxa with the  
                   largest difference in score for best/worst locations (N.B. 
                   all character types are considered). Works best for the 
                   same data sets as the previous one ("ias"), but it is 
                   more thorough and slower 
    Usage: "mult:options;" changes settings only; "mult=options;" runs 
    as well.  Entering "mult:;" current settings are reported.  Setting 
    the type of addition sequence also determines the sequence to be used 
    in other commands (e.g. "xmult", "pfijo").  The insertion sequence 
    is always random for "cas", "sas", and "fas"; it can be changed (see 
    under "rseed") to be random or non-random for "ras" and "ias" 

    N   Use N Mbytes of RAM.  The default is 16 MB. 
        Must be changed before reading the data, or the  
        data will be lost. 
    ;  report amount of free RAM 

    N   allow up to N nested input files (default=10) 

    =   show tree diagrams without numbers (default) 
    -   with 
    ]   draw trees in narrow format 
    [   in default (=wide) format 

    Calculate strict consensus tree 
    N/L    display consensus for tree(s) N, excluding taxon (taxa) L 
    *N/L   same, but keep consensus as last tree in memory 
    N/L/P  display consensus for tree(s) N, excluding taxon (taxa) L, 
           and indicate placement of taxon (taxa) P (P may refer to 
           node numbers in the consensus) 
    <      always use low-memory algorithm (sometimes, faster) 
    >      use low memory algorithm only when memory is low 
    Note that settings established with ">" and "<" also 
    affect the "tcomp" command. 

    N    set maximum number of states in matrices to be subsquently read to N 
         Note that 8 or fewer states is stored as char, 9 to 16 as Tint 
         and 17 to 32 as Fint.  Maximum number allowed for discrete data 
         is 32 states.  Letters A-J are states 10-31. 
         Using the strings "DNA," "PROT," or "NUM," determines 
         whether data are read as dna, amino-acids, or alpha-numeric. The 
         string NUM must be followed by the number of states; DNA or PROT 
         automatically set number of states to 8 or 32. Under DNA or PROT, 
         IUPAC one-letter codes represent nucleotides or amino-acids. 
         For DNA, AGCT are states 0123 respectively; for proteins, 
         A,C,D,E,F,G,H,I,K,L,M,N,P,Q,R,S,T,V,W,Y,U are states 0-20. 
         Strings "GAPS" and "NOGAPS" determine whether gaps are read 
         as fifth state or missing (respectively). 
    *    resets all characters as alphanumeric; subsequent 
         merging of data sets with different data sets becomes easier if all 
         data sets are saved as alpha-numeric 
    &    like previous one, but sets all characters to type DNA. 
    min  deletes uninformative states for non-additive characters, so that 
         each character has as few distinct states as possible 
    xmin for non-additive characters with polymorphisms, calculate minimum 
         possible numbers of steps (and thus, informativeness and homoplasy) 
         using exact algorithms (=default; these may be time consuming for many 
         states and many polymorphisms).  With "noxmin", a heuristic is used 
         to determine minima (it may underestimate minimum). 
    /    followed by the strings "DNA," "PROT," or "NUM,"  determines 
         how to read states in commands that refer to states (i.e. cost, or 
         change commands).  This does not alter the matrix itself. 

      N     make taxon N the outgroup (default = 0 ) 
      [XXX  if taxonomy has been defined, make group "XXX" the  
            "taxonomic outgroup".  This is a possibly multi-taxon 
            outgroup, which may be used to root the trees after  
            searches, or with the "reroot[" option.  In case the  
            taxonomic outgroup does not exist in the tree, the closest 
            group is used (if nothing resembling the ingroup/outgroup 
            partition exists, then a note is displayed, and the tree is 
            left rooted on the regular outgroup). If the name "XXX" is 
            ommitted, then the taxonomic outgroup is guessed form the  
            taxonomy.  To have TNT reroot the trees after a search, use 
            "!" before the category name (default is rerooting trees 
            onyl when a "reroot[;" command is issued). 
            Note that if you have some Sankoff characters with asymmetrical 
            transformation costs, or have the "piwe+" option in effect, 
            then it is possible that using the taxonomic outgroup may 
            alter tree scores. 

    Redirect input 
      XXX;   take commands from file XXX 
      /;     close input file (include at end of file) 
      &XXX   read Fasta file XXX.  It must be aligned.  If not, all 
             sequences can be "equalized" to N characters, by adding 
             gaps at the end, if & is followed by =N (alternatively, 
             =N can be placed at the beggining of the file. 
    Note that input may also be redirected automatically (almost  
    within any context) using "@@filename tagname;" (reading is 
    from point marked with "label tagname" on, with end of 
    automatic redirection indicated with @@; if a dash, -, is used 
    instead of tagname, the file is done from the begginning) 

       =   enable pauses on output 
       -   don't (default) 

    Improve consensus by Iterative PCR (Pol & Escapa, 2009). 
         N/L\U      improve consensus of tree(s) N, excluding taxa 
                    in list L, but never removing taxa in U. 
    List of trees may be preceded by:  
          =C        maximum number of taxa to cut at a time (default=all) 
          :K        assign a cost of K (0-100) to taxon remotion (higher 
                    K's require more nodes gained for a taxon removal to 
                    be accepted as "improvement"; default=0.5) 
          >N        only show prunings which improve N nodes or more 
                    (for strict consensus only, not for majority) 
          [N]       improve only node N of consensus (for strict  
                    consensus only, not for majority) 
    and if followed by ">N", all the prunes are added to taxon-group 
    number N (note that this option requires an explicit tree list, for 
    otherwise it would be interpreted as the option to only show prunings 
    which improve N nodes; see above). 
    The consensus types can be indicated in parentheses, also before 
      (majority F)  heuristically try to improve majority rule tree,  
                    considering that triplets occurring in frequency F  
                    or higher are "compatible" (50<=F<=100, default=50) 
       (nelsen)     improve strict consensus tree (=default) 

    Run pinon fijo (a search algorithm useful for very large data sets). 
    The algorithm creates reduced data sets from sectors in the tree 
    (but instead of using the htu's, as in sectsch, it uses, with a certain 
    probability, the down-pass states of the descendants of an internal node). 
    The states for the basal node --which produce exact score evaluations for 
    the reduced data set-- have the highest probability of being chosen, and 
    descendant nodes have subsequently smaller probabilities.  The outgroup 
    node for the reduced data set is chosen from one of the terminals outside 
    the group (randomly chosen). The reduced data set is analyzed by means of  
    three RAS+TBR, then fusing these three trees with the original one. 
    Typically, this produces a tree different from the original one, which 
    is suboptimal for the complete data set (i.e. some HTU's are not 
    represented by their down-pass states, the root states are different), 
    and this perturbated tree is then used for TBR and three cycles of  
    mild tree-drifting.  Optionally, the trees produced can be fused every 
    certain number of rounds.  This is a sort of ratchet, where the  
    perturbation is provided, not by character reweighting, but instead 
    by choosing subsets of taxa. 
      The sectors chosen are large, exclusive sectors (size chosen so that 
    it is below or above two sectors for the sector size to be 500; this 
    size can be changed, with "chunksize" --see syntax below); the actual 
    selections depend on the current random seed. 
      The probabbility of choosing HTU states is determined by making an  
    upward list of the L nodes descended from the HTU, generating a random 
    number R (0-99), and based on the user-set constant K, converting into an 
    integer i the expression ( L * (1000 - (10*K) ) / ( (100 - (10*K)) + R ). 
    Then, the down-pass states (or observed states, if a terminal) of the ith 
    element in the list of descendants is chosen to represent the HTU states. 
    Syntax is:  
                 pfijo N = [options] ;  
    If the '=' is replaced by ':', then only settings are changed. 
    N is the tree from which pfijo is to be started (if no N is specified, 
    each of the trees in memory is sequentially subjected to pinon fijo). 
    Options are:  
       phtu K   Change probability of HTU substitution.  K is a real number  
            0<0<100, with larger values making more probable that the actual 
            HTU states are chosen, i.e. lower values perturbate more strongly; 
            (default K=95) 
       numsels N   number of cycles to do (default N=30) 
       [no]goback  if new tree, after global TBR and drift, is worse than 
            starting tree, go back to starting tree (default = don't go back) 
       [no]keepall   save trees as cycles proceed, or save only best trees 
             (default: save) 
       autofuse N R  every N cycles, fuse (R rounds) the trees produced. 
       drift N F R  after perturbation, do N cycles of drifting, with a fit 
             difference F, and a relative fit difference R (default is  
             drift 3 3 0.1) 
       chunksize N  select sectors of approximmate size N 
       slack N  use an extra N percent memory to create reduced data sets 

      -    set implied weighting off (=default ) 
      =N;  set it on, with weighting constant N (0 < N <= 1000) 
      :N   set weighting constant only 
      [    followed by a list of weights, sets relative weights for 
           implied weighting (starting from 0 extra steps). Followed 
           by a semicolon, displays current relative implied weights 
      ];   deactivates user-defined implied weights 
      +N   use auto-weighted optimization instead of implied weights, with 
           weighting constant N.  This does implied weighting at the level 
           of character-state transformations; it can be very time-consuming  
           for data sets with many taxa and/or states. 
       &   when using multiple concavities, show k values for individual 
           characters (if not using a user-defined weighting function), 
           or the "shift" (for a character with shift S, the cost of adding 
           one step to N steps of homoplasy is the same as the cost of adding 
           a step to a character with S.N steps with the user-defined weighting 
           function.  If a list L of characters is given after after "&, then 
           the relative cost of adding a step to a different numbers of extra 
           steps (as in "piwe[;"), for the characters in L. 

    Find pruned combinable component consensus.  Syntax as in  
    "prunnelsen" --options + and ! not allowed. 

    Use a quick-and-dirty heuristic to identify taxa to prune 
    in order to improve majority rule or frequency difference 
    trees.  It checks by reference to specific groups (i.e. groups 
    present in a reference tree).  General syntax is (defaults in 
    square brackets): 
                prunmaj T N1 N2 N3 .. Nn / S / L \ U ;  
    where T is number of reference tree [mandatory], N1-Nn are node numbers 
    [all], S is the set of trees to consider [all], L is the list of taxa 
    to exclude [none], and U is the list of taxa that cannot be excluded 
    from the tree (=Untouchable). 
    Additional arguments that can precede number of reference tree: 
       &P      group proportion [0.333].  Set only, don't run. 
       [X Y    cost of removal inside (X) and outside (Y) [1,1]. Set only, 
               don't run. 
       +       show pruns for each node of tree T [don't]. 
       =N      show the best N values [1]. 
       *       try to improve frequency differences, rather than 
               just frequencies. 
    It is possible to add/remove taxa from taxon-groups, as final 
        >G      add taxa with best N values to group G. 
        <G      ditto, removing. 
    The values are presented with an arbitrary rescaling between 0 and 
    1, with taxa having higher scores expected (recall this is a heuristic!)  
    to improve results the most. 

    =P N/L Show pruned trees with up to P taxa pruned (default=1) 
           for consensus of tree(s) N, excluding taxon (taxa) L. 
           Checks whether additinal groups appear.  If you wish to 
           force inclusion of some taxa (terminals only), list them 
           at the end as "\L". 
    [J]    same, but only for node J of consensus 
    &      show list of prunings that improve consensus 
    *      store prunings that improve consensus (pruned 
           taxa are placed at the base of the tree) 
    >N     show only prunings that improve more than N nodes 
    +      calculate agreement subtree (cannot be used with 
           =, [N], or >, but can be used together with * or &). 
           Agreement subtrees maximize number of shared taxa, 
           not number of shared groups (although both are the 
           same for binary input trees) 
    !      approximate calculation of agreement subtree (for 
           binary input trees only). If used alone quickest, 
           if used with + intermediate. Saves or lists a single 

    N/L   prunes taxon (taxa) L from tree(s) N.  If symbol 
          "!" is used as taxon list, it prunes all inactive 
          taxa.  If "*" is used instead of tree list, then it 
          prunes taxa from tag-tree; using "=xxx;" instead of 
          taxon list, then it prunes all terminal branches labeled 
          as "xxx". 

    manage runs in parallel (parallel versions only).  Keep in mind that 
    versions for 16383 taxa or less can't communicate with versions for more 
    than 16383 taxa (mixing 32-bit and 64-bit versions should be ok). 
    again    re-send instructions to slaves, without re-sending data. With 
             this, it is possible to save communication time. Syntax is: 

                  ptnt again jobname tasklist /trees N S /deltrees /swap N 
                             = slave commands...; return;  

             if no tasklist is given, all the tasks of jobname are re-set; 
             if no "trees" selection is specified (and "swap" isn't 
             specified), then no trees are sent; if "deltrees" is 
             indicated, the trees in slave(s) are deleted. 
             If "swap N" is specified, then it swaps tree N (deleting any 
             preexisting trees in the task); if several trees are to be 
             swapped in parallel, it is best to use "again" instead of 
             "begin" for each one, since "again" doesn't require that 
             the data be re-sent to the task(s) ("begin" does!). 
             Using "..." as instructions, then the previous instructions 
             for the slave are repeated.  
    begin   begin a job.  Up to 32 jobs can be running at the same time; 
            every job can have up to 1000 tasks.  Syntax is: 

                  begin name numt hosts = tnt commands ; return  

             name is the name by which the job is identified, numt the  
             number of copies of the process to run, hosts is a list of 
             the hosts in which to run (can be the names used by PVM, or 
             the numbers; current host is identified as "myself" and 
             host of parent process (if it exists) is identified as  
             "parent" (this makes scripts more portable; also, in the 
             list of hosts, the machine where the master TNT runs is 
             always number 0, and the machine where a slave itself runs 
             is always number 1 within that slave); "master" identifies  
             the master node (i.e. where TNT was started). When no list 
             of hosts is given, if the executing process is the master, 
             all hosts but the current one are used, or, if the process is 
             a slave, all hosts but the one where parent process runs. If 
             neither numtasks nor hostlist are given, one task per available 
             slave host is used (except for exclusive sectors, which spawns 
             as many tasks as selections).  If you wish to specify the 
             number of tasks to be spawned in a host (or group of hosts), 
             include the number of tasks in parenthesis right after the  
             name of the host (or group of hosts, i.e. before the closing 
             braces).  If several numbers of tasks are specified, the last 
             one takes effect (no number = 1). Current (or reduced) data are 
             automatically passed to each of the daughter processes (each 
             of which has a different random seed).  The '=' symbol can be 
             preceded by one or several slashes ('/') indicating: 
                ram N      N: RAM to be used in each slave, in MBytes  
                           By default, TNT instructs each slave to allocate 
                           an amount of RAM that should be sufficient for  
                           most operations on the current data set. 
                ram xN     slaves use N times default RAM 
                trees N S  send N trees randomly picked from the total S 
                           to each slave; using '.' instead of N, divides 
                           S in equal parts 
                trees *    distribute trees groups, sending task i all the 
                           trees in group i 
                sector N S random selections of size N from tree set S 
                           (as many selections as tasks; every task gets 
                           a sector from a tree randomly picked out of S) 
                sector*N T create N exclusive sectors from tree T 
                           (size set to taxa/N, tasks set to N). 
                           If "*" followed by "-", allow looser 
                           (partly randomized) selections.  If a list 
                           of sectors follows N (within square brackets), 
                           then only those sectors are effectively launched. 
                           When only some sectors were launched, and results 
                           are recovered/spied, two copies of the best tree 
                           in each slave (with the rest of tree polytomized) 
                           are placed in tree-group "TreeSector_i_xxx" 
                           (where i, task number, and xxx, job name).  This 
                           can be used to re-insert the resolution for the 
                           sector into the main tree, or combining the 
                           results for successive sector analyses, using 
                           the "freqdifs" command (i.e. two copies of the 
                           reduced tree and a single copy of the original 
                           one, produce the replacement; make sure you 
                           turn temporary tree-collapsing off for this). 
                           Note: under "sec:chkroot" the number of sectors 
                           created by this options is determined at run-time; 
                           use the "treeparts" expression to find in 
                           advance how many. 
                sector d N X  select nodes around node N (of tree specified 
                           with "/trees"), up to X branches away from N. 
                sector !N >X <Y T  select node N of tree T and immediate 
                           descendants; if a descendant has a polytomy 
                           greater than Y, or smaller than X, it is used 
                           as such; otherwise, the immediate descendants  
                           of the node are used (this avoids creating HTU's 
                           from poorly, or unresolved clades). To create 
                           the HTU-s, the tree is dichotomized if needed. 
                swap N     perform TBR-swapping in parallel, on tree N. 
                           When done, task 0 has the final tree (which, 
                           if no errors occur, is TBR-optimal).  If some 
                           error occurs (e.g. machine where process 0, 
                           which is the leader, dies), then the tree is 
                           lost. This works best when trees are closest 
                           to optimal (i.e. communication time is required 
                           only when a better tree is found by some task). 
                           When using "swap", instructions to slave tasks 
                           are ignored (tasks only swap tree, and return). 
                           Options: -N doesn't sort swaps; +N uses process  
                           as controller (controller doesn't swap) 
                dskdata    read data from disk, not from PVM (data must 
                           have been set before, with "ptnt setdata"). 
             If several "trees" selections are indicated, selection i is 
             guaranteed to have at least Ni trees taken out of each set Si; 
             up to 8 tree selections per job can be indicated.  If the sets 
             for each selection i are disjoint, total number of trees sent 
             to each slave will be the summation of the individual Ni's; 
             otherwise, it may be less. 
                 A slave may begin other parallel jobs; if it does so, 
             giving "..." as list of TNT commands simply copies commands 
             for the current job (use this caution: there must be a way to 
             eventually stop slaves from spawning further jobs, e.g. with 
             the "plevel" expression --the number of parents).  User 
             variables are interpreted on local host when using single 
             quotes ('0') and on slave host when using double quotes ("0"). 
             String "return" must be followed by keywords "[no]trees", 
             "text", "value N" or "tgroups" (if exclusive sector 
             selection, options "polytree" and "nopolytree" determine 
             whether polytomized tree is sent back; otherwise polytomized 
             tree is sent only if initial score bettered/matched). 
    cleansig remove any signals with info from slaves that may have 
             been left over by the last "wait".  It may be necessary 
             if "goto" or "again" are to be applied to a job that 
             had finished running, and the job is to be "waited" 
             again.  It is also advisable to run this (with "again") on 
             slaves interrupted (=stopped) while doing parallel TBR 
             and about to be reused for further parallel TBR. 
    close    kill all active jobs and disengage TNT from PVM.  With this,  
             PVM can be halted and TNT continues running normally. If PVM 
             is halted and TNT is in parallel mode, TNT is killed. 
    cmdname  define name of command to be displayed by parent process 
             (copies until a semicolon found; "-" undefines). 
    commtime set communication time (periodicity of signaling). 
    encode   set type of encoding for communication with slaves. Options 
             are "raw" and "default" (for single/several machine 
             architectures).  Must be set in slave processes too. The 
             default is using the current status, but this may create 
             problems if a homogeneous cluster becomes heterogeneous 
             (or viceversa) in the middle of a run. 
    get [!]  get results from job(s).  Job(s) must have finished running 
             (or have been stopped (with "ptnt stop job;").  If jobs 
             have not finished, "get" waits for the last one to finish 
             (or untill timed-out). Alternatively, if using "!" as  
             first argument to "get", slaves are stopped right away 
             (with the default stopping signal, see below). If get is 
             being executed in the master, it can be stopped pressing <esc> 
             (which calls the error handler, clearing all input buffers), 
             or pressing '.' (period, which skips the get but continues 
             normally with the rest of operations.  If a single job is 
             being retrieved, maxtrees is reset automatically (if needed); 
             if several jobs are retrieved at the same time, maxtrees  
             is not reset (excess trees are lost). 
    goto N   similar to skipto, but if "tagset N;" already executed, 
             rewinds instructions. 
    gwait () monitor, and when condition fulfilled, stop jobs and get'em. 
             (note: gwait never resets maxtrees; excess trees are lost). 
    hgroup   define group(s) of hosts (syntax as in "tgroup") 
    hosts    list available hosts 
    hpause   pause all slave tasks working in given host(s). 
    hresume  resume all slave tasks working in given host(s). 
    kill     kill job(s); no results returned. 
    load     show host usage 
    mnemonic when possible, remember values read in last ptnt wait (then 
             subsequent accesses to number of trees, scores, etc., in 
             slaves, take no time; note however that the values may not 
             be current anymore).  If memory is reassigned (e.g. max. 
             trees is changed), then values are forgotten.  Mnemonic is 
             turned on/off with +/-.  
    pause    pause job(s); releases CPU time (but not RAM) on slaves  
             Can pause individual tasks (say, 0,3)for job jobname 
             using "ptnt pause jobname = 0 3;".  If master is running 
             in the background, all jobs can be paused by creating a 
             file "pause_tnt_ID" (where ID is the number of process 
             id of master) in the working directory (using "stop_tnt_ID" 
             instead, all jobs are stopped) 
    reset    reset job list (no active job can be running). Memory 
             requirements on TNT are eased if this is done often. 
    resume   resume job(s) that are paused (automatic with "get"). 
             Can resume individual tasks (say, 0,3)for job jobname 
             using "ptnt resume jobname = 0 3;". 
    setdata  write data file (.tnt_tmpfile) in specified hosts(s) 
             (can indicate other directory, in square brackets, after 
             list of hosts; in such a case, then before launching jobs 
            you have to tell TNT where the directory is, with  
             "ptnt setdata = dirname;").  After setting disk data, 
             subsequently started jobs can read the data from disk 
             instead of having PVM transfer the data (which is time 
             and memory consuming), using the "dskdata" option. 
    setram N instead of master assigning RAM to slaves (based on 
             current settings), assign a fixed amount of N (MBytes) 
    skipto N skip instructions, in job/slave(s) specified, to the point 
             marked with "tagset N;" (if already there, ignored). The 
             slave cannot find a tag within a loop, and must still 
             be executing instructions (skipto is ignored if slave 
             is already on "return" stage, i.e. the last tag). 
    spy      get trees from job(s), but let the jobs continue running. 
             If a single job is being specified, a list of tasks(s) 
             can be specified as well (after a forward slash). Note: 
             this only gets the trees from immediate slaves (not their 
             children or grandchildren).  Maxtrees reset automatically 
             (as in get), only when a single job is being spied. 
    status   report status of all active jobs. 
    stop [s] stop job(s); returns results so far. 
             Optionally, stopping signal can be determined inside 
             square brackets: wait, loops, search, or all. Wait stops 
             the monitoring for slaves (present and future), but not 
             calculations or searches themselves. Loops lets presently 
             executed loops to continue, but subsequent ones are stopped. 
             Search assumes the timeout for present and subsequent 
             searches to be always met; it doesn't stop other calculations 
             (such as consensus calculations).  All stops calculations, 
             searches, monitoring (wait), and loops.  The default 
             stopping signal (which is the one get ! uses) has a different 
             effect depending on what the slave is doing; if monitoring, 
             (with pt wait) the monitoring is interrupted and subsequent 
             instructions (like searches) are performed; if searching, 
             the search is interrupted and the slave returns right away. 
    tagset N define tag to be N (useful within slaves, to coordinate 
             tasks; see under help+attag, and above, under "skipto" and 
             and "goto").  This is also a plain command. Truncations of  
             tagset are recognized to set values, but skipto/goto only 
             recognize the entire string. 
    timeout  set timeout (in secs.) to wait for slaves to return results 
             with "get". Default is no timeout (=0), but this may cause 
             fault-intolerance (i.e. TNT may freeze if a slave host died). 
    wait ()  monitor specified jobs (until condition indicated inside paren- 
             theses is met).  Numbers of trees, replications, tasks left, 
             &cetera, are accessed periodically (then, evaluated faster if 
             TNT is monitoring; otherwise, unless "mnemonic" is on, 
             signals requesting values must be sent to slaves, and  
             parent must await for response). If no condition is specified 
             it waits for all tasks to finish. A timeout can be specified, 
             before the parentheses, inside square brackets; if timeout 
             is met, wait exits even if condition is not fulfilled 
             (but then waitsuccess=0). 

    =   quick pre-collapsing during searches under mulpars (default) 
    -   no quick pre-collapsing 

    Estimate consensus. Options are: replications N, select N, strictperc N, 
    majorcut N.  Search commands given in square brackets. Taxon exclusion with 
    "/" followed by list of taxa to exclude (from consensus; not from searches) 
    For each search, trees are collapsed according to current criterion. Option 
    "allow" works as in the resample command. When majorcut=100, then 
    the strict consensus for all replications is calculated. 

    copy from input to output until a semicolon is found 
    (if literal quotes is off, start on a new line, otherwise 
    new lines on output reflect new lines on input) 

    quit the program 

    N J K  create N random trees, by adding taxa at each pre-existing 
           branch with same probability, probability J of collapsing  
           the new node, with up to K-furcations (default J = 0 ) 
    /      randomize tree order 
    *      randomly resolve non-binary trees 

    Ratchet, from trees in memory.  Options are:  
       iter N           number of iterations 
       [no]equal        periodic rounds with original weights [not] 
       numsubs N        number of replacements (i.e. accepted tree 
                        rearrangements) to do in perturbation phase 
       upfactor N       probability of upweighting a character 
       downfact N       same, for downweighting 
       [no]autoconst N  number of auto-constrained cycles 
       [no]giveup N     percentage of full swap to complete during perturbation 
       findscore N      if score N or better found, stop 
       [no]fuse NxR     every N iterations, do R rounds of fusing to the N 
       [no]dumpfuse     if fusing fails to produce a better tree, [don't] 
                        dump all the suboptimal trees 
       [no]tradrat      [don't] run the original ratchet (i.e. noequal, 
                        during perturbation swap to completion and don't 
                        accept equally good rearrangements). 
    Options are set with "ratchet:[options];" or "ratchet=[options];" 
    (first case changes settings only, second case runs as well). With 
    "ratchet:;" current settings are displayed 

      B    Identify sequences that seem reverse-complemented in block 
           list B (only DNA blocks are processed; blocks with non-DNA 
           characters are skipped).  The command calculates the edit cost 
           (Needleman-Wunsch) of the sequences as they are (A), and with 
           one of the sequences reverse-complemented (R).  If A < R, then 
           both sequences are considered to point in the same direction 
           [if (R-A)/A < 0.2, then TNT considers that no decision as to 
           direction can be made].  If A > R, then it is assumed that one 
           of the sequences is reverse-complemented [again, only when  
           (A-R)/R > 0.2].  Using ">G" after the list of blocks, all 
           sequences (=taxa) that seem reverse-complemented are added 
           to taxon-group G. 

    xxx    set path for "run" files 

    Do a ratchet-like search, with perturbation provided by randomly pruning 
    taxa from current tree, re-inserting sequentially, and swapping with TBR. 
    This command is useful for very poorly structured data sets (e.g. random); 
    similar to the "*" option of the "hybrid" command, looped many times. 
    The number of nodes deleted can be a fixed proportion ("pclip") or an 
    absolute number ("clip"), of terminals or clades of a specified "size". 
    This is done repeatedly (as in the ratchet); optionally, it is possible to  
    use the (best) results of the cycles as input for tree-hybridization (with 
    settings from "tfuse" command).  One of the best trees produced by  
    hybridization is then used to continue the rebuilding. 
    Options (possibly preceded by "no"):  
       clip J-K  at every cycle, clip a number of nodes between J and K. If 
                 this not specified (or 0), then it uses "pclip". 
       pclip N   at every cycle, clip N% of the terminals or nodes. 
       size N    maximum size of clade to clip (default=1). If N > 2, then 
                 (by default, see "ancfirst" option), clades are re-inserted 
                 back before their descendants.  If this set to 0, then it 
                 uses "psize". 
       psize N   maximum size, as proportion (%) of number of taxa. 
       cycles N  do N cycles of rebuilding. 
       reset N+S every N cycles that fail to produce a tree as good as best 
                 tree found so far (plus S, if specified), reset tree to 
                 best tree found so far and continue rebuilding from that one. 
                 Default = "noreset". 
       hybrid N  hybridize, N times, the best S trees produced by rebuilding 
                 (S=sample size, determined with "sample").  Each round of 
                 hybridization will use the results from as many cycles as 
                 specified with "cycles".  Default = "nohybrid". 
       sample N  pass to the hybridizer the best N trees produced by rebuilding 
       ancfirst  If clipping clades of more than 2 terminals, reinsert ancestors 
                 before descendants.  Default = yes. 
       keepall   keep all trees produced by rebuilding, instead of best ones. 
       dump      after hybridization, if too many trees match best score, retain 
                 a small sample (10% of sample size), so that trees from new  
                 cycles of rebuilding can be saved for subsequent hybridization. 
                 With "no", hybridization becomes easily stalled by using a 
                 fixed set of near-optimal trees.  Default = yes.  
    Options are set with "rebuild:[options];" or "rebuild=[options];" 
    (first case changes settings only, second case runs as well). With 
    "rebuild:;" current settings are displayed. 

    N/L;    most parsimonious reconstructions for character(s) L, tree(s) N 

      =         report status of time-consuming operations 
      -         don't (default) 
      +S/R/T;   during searches, record status every S seconds, R replications, 
                or T trees swapped (no record = 0 ) 
      [         with the +S option, also record progress bar when running 
                in background, every S seconds 
      ]         don't (default) 

      N   re-root tree(s) N, using current outgroup 
      [N  re-root tree(s) N, using taxonomic outgroup (see "outgroup") 
      *   also re-root tag-tree. The tags for groups which become paraphyletic 
          are assigned to the (now monophyletic) complement group (i.e. tags 
          remain in the same taxon partitions). 
      =P  re-root tree(s) (and tree-tag, if using '*') on point P 
          (if rerooting several trees, and P is an internal node,  
          this may imply different rootings for different trees). 

    Resample matrix, and calculate group supports. 
    Usage: "resample options [ search commands ];"  Options are: 
       jak             use normal jacknifing (i.e. independent deletion) 
       sym             use symmetric resampling, with p(up)=p(del) 
       boot            use normal bootstrapping 
       poisson         use Poisson-modified bootstrapping 
       probability N   change probability for "jak" or "sym" 
       replications N  number of replications 
       cut N           cutoff frequency or support 
       slope           summarize results with frequency slopes 
       gc              summarize results with frequency differences 
       frequency       summarize results with absolute frequencies 
       from N          calculate support for groups in tree N 
       savetrees       save consensus for each replication 
       allow           during each replication, allow execution of 
                       (almost) all commands, including dangerous ones. 
                       This option should be used sparingly and only when 
                       you really know what you're doing! 
       zerowt          if doing symmetric resampling, eliminated (give 
                       weight 0) to downweighted characters (=default); 
                       otherwise, divide their weight by 2 (uncontra- 
                       dicted groups appear in all replicates) 
       sibyl           perform a backwards-jacknife; if used, this 
                       must precede all other arguments. See below 
                       for details. 
       errcount N      valid only under sibyl.  This counts the  
                       proportion of groups (out of the total 
                       supported groups) in the reduced data set 
                       that are not supported in the complete data 
                       set (wrong groups) and the proportion of groups 
                       (out of the total) in reference tree N (presu- 
                       mably, consensus of optimal trees for the 
                       complete data set) that are not supported by 
                       the reduced data set (mist groups). 
    Taxa can be excluded from consensus calculations, using "/" followed  
    by the list of taxa to exclude.  All options are persistent, except 
    taxon exclusion and "from" 

       The backwards jacknife is not a measure of support, but provides 
    instead a sort of stability test. It deletes characters (under 
    independent character removal, with p(del)=0.33); for each case, 
    runs the data (as indicated within square brackets) and count the 
    number of groups supported by the reduced data set that are present 
    in all previously existing trees ("supported") or present in some 
    but not all existing trees ("compatible").  Divide that number by 
    the total number of groups supported in the reduced data set, or by 
    the total number of groups that _could_ be supported in the reduced 
    data set (i.e. nr. of taxa-2 , "normalized"). The existing trees must 
    be provided by the user, and should correspond to a set of optimal 
    trees under current settings. Other than search commands, only the 
    number of replications can be changed, and taxa can be disregarded. 

    N/L;   show resolutions of polytomies in consensus of tree(s) N, 
           excluding taxon (taxa) L 
    [J]    same, only for node J of consensus 
    &      list resolutions 

    [T] N/L  show frequency of approximmate recovery of groups 
             from reference tree T, in tree(s) N, excluding taxon 
             (taxa) L. For each group of T and each tree, it calculates 
             the "similarity" S to most similar group of tree, with 
             S defined as B/(B+(AxWa)+(RxWr)), where B=number of taxa 
             in both groups, or in neither (whichever is smallest), 
             A=number of taxa added to group, R=number of taxa 
             removed from group (Wa and Wr are weight factors to make 
             removal/addition more costly, set with "prunmaj") 
             If group adds/removes more than a certain proportion of  
             taxa (default is 0.333) then S=0. 

    ;    deactivate duplicate taxa (according to current 
         character activities) and prune trees 
    *;   same, but leave two identical taxa active and in 
         trees (takes into account zero-length branches) 
    -    reactivate and reinsert duplicate inactive taxa 
    /    reinsert duplicates into tree-tags 

      N    set random seed as N ( 0 = time ; default = 1 )  
      +N   increase random seed by N 
      *;   set a new random seed, at random 
      [;   in wagner trees, randomize insertion sequence 
      ];   in wagner trees, try insertions for new taxa from 
           top to bottom or from bottom up (=default) 
      >    in wagner trees, also randomize outgroup.  This  
           cannot be done when there are constraints or  
           asymmetric Sankoff characters (randomization is 
           skipped). Note that some "xmult" options use 
           internal constraints (and then skip randomization) 
      <    in wagner trees, outgroup is always the first taxon 
           placed in the tree (=default) 
      :N;  in multiple randomizations, instead of making sure 
           that each new seed is different from the ones used 
           before, increase the seed by N.  This may save time 
           in very extensive randomizations (where checking 
           previous seeds takes time).  When N=0, checks previous 
           seeds (this the default). 
      !    use quick approximation for randomization (faster) 
      -    use careful randomizations (slower, more random; default) 

    xxx arg1 arg2 ... argN; 
          parses file xxx, replacing %i by arg i 
          (max. args. = 32, arg 0 is file name) 

    save trees to file (previously opened with "tsave") 
    N    save tree(s) N. 
    /    save last tree in memory 
    *    save tree-tags in parenthetical notation 
         (tree-file must be parenthetical) 
    -    save trees numbering only active taxa 
         (in combination with xread-, saves reduced 

    NxL   use screen of N lines and L rows 

    N   calculate tree-scores (length or fit), for tree(s) N 
    !N  same, optimizing polytomies as "soft" 

    Comparisons of tree-shapes.  Work in progress. 

    Do sectorial-search, starting from pre-existing trees. Options are: 
    For determining choice of sectors: 
      rss          do random sector selections 
      css          do constraint-based selections 
      [no]xss N+R  do N exclusive (i.e. non-overlapping) sector selections, 
                   covering all tree, and analyze each; repeat process R 
                   times or rounds (after the last one, do global TBR). 
                   If R is followed by -G, then global TBR is done every 
                   G rounds (and after last one).  Using B-E instead of N 
                   division starts at B and ends at E (increasing or 
                   decreasing, depending on whether E>B or B>E) 
      dss N D      select nodes around node N, up to D (=diameter) branches 
                   away from N, and analyze sector.  This requires specification 
                   of a tree; it never swaps at the end (as in noglobal) 
      [no]xeven    for exclusive sectors, [don't] use sectors of as even 
                   a size as possible (uneven sectors make it more likely 
                   to find better trees if using several rounds 
      minsize N    minimum size for random selections 
      maxsize N    maximum size for random selections 
      minfork N    minimum fork for constraint-based selections 
      maxfork N    maximum fork for constraint-based selections 
      increase N   factor to increase size if enough selections of current 
                   size completed. New size is S = S + ( ( S * N ) / 100 )  
      selfact N    factor to determine (under random selections) maximum number  
                   of selections of size S, for T (active) taxa.  Maximum 
                   number, M, is determined as M = ( T * 100 ) / ( N * S ). 
                   Alternatively, using "selfact = X Y Z" uses X for the 
                   first selection, Y for the second, and so on (up to 30 
                   values can be defined) 
      moveon N     if N selections fail to produce a better score, move on 
      rounds N     for constraint-based selections, cycle N times over groups 
    For determining analysis: 
      global N     for smaller selections, do global TBR every N replacements 
      dglobal N    same, for larger selections (i.e. under drift and combined) 
      noglobal     never swap globally. 
      [no]equals   accept equally good subtrees 
      [no]fuse N   when analyzing small sector (below drift size), keep 
                   all trees and fuse (N rounds).  Note: for sectors above 
                   drift size, the autofuse option of drift applies. 
      godrift N    sector size above which tree-drifting (not RAS+TBR) is used 
      drift N      for drifted sectors, use N cycles of drift 
      gocomb N     for sector of size N or more, use combined analyses 
                   (RAS+drift+fuse).  If N is smaller than the size to 
                   use drift, drift is not done.  Number C of drift cycles 
                   for each start is determined with drift C, number F of 
                   fuses is determined with fuse F. 
      starts N     for sectors below minsize, number of randaddseqs plus TBR 
      combstarts N for sectors above size for combined analyses, use N starts 
                   (if first N yield same score, stop, else do N more starts) 
      findscore N  stop drifting on tree if score N found 
      [no]keepall  keep only the best trees [don't] 
    General options: 
      [no]safesank for sankoff characters, use strict checking (=default) 
                   to identify uninformative characters for reduced data set 
                   (looser checking may produce small speedups, but may miss 
                   better trees for complex transformation costs). 
      slack N      make N percent extra memory for searches (prevents 
                   memory errors during runs 
      [no]xbuf     if memory is available, use independent matrix-buffer 
                   for analysis of sectors (=faster updates, significant 
                   time saved for small sectors in large data sets). 
      recurse N    allow sectorial searches to recurse up to N levels 
      tree N       select sectors for tree N (instead of all trees) 
      track        allow tracking nodes between big tree and reduced 
                   tree (valid only for sectorial searches with user 
                   instructions).  This is to be used in combination 
                   with macro expressions "nodtosect", "biginsect" 
      chkroot      for XSS searches only, make sure the base of tree (which 
                   often may be unselected) is included as well; this may 
                   actually use one more selection than requested. 
                   and "bignotsect".  A slave running a sector (see 
                   under "ptnt") always allows tracking. 
    Options are set with "sectsch:options;" or "sectsch=options;" (using 
    ":" only settings are changed; "=" runs as well). With "sect:;"  
    current settings are displayed. 
       It is also possible to determine specifically how to search for 
    each sector generated, including the commands to search within square 
    brackets (including sectsch itself, possibly with user instructions as well). 
    Maximum level of recursion has to be determined with "sectsch: recurse N;" 
    before reading data set.  When using user instructions for each sector, 
    any settings changed for analyzing a subproblem will remain changed after 
    concluding analysis of the sector (the only exception to this is settings 
    for sectsch itself). 

    xxx     read trees (compact) from file xxx 
    =N xxx  same, but place them in group N 
    >N xxx  same, but add them to group N 

    Control output to xxx: 
       =xxx;    no output to xxx. 
       -xxx;    output to xxx. 
    "xxx" can be "all," "file," "console," or "buffer." 

    Set parameters for auto-weighted optimizations (defaults in 
    square brackets): 
        exops N        for characters with more than N states, 
                       pre-check transformations and forbid those 
                       not occurying under a lineal optimization. [5] 
        timeout N      use no more than N seconds to calculate 
                       optimization for any given character. [3600] 
        tolerance N    accept reconstructions that differ from 
                       optimal in N units of score. [0.0000001] 
        [no]polymorph  during optimization, [don't] consider polymorphic 
                       taxa as having a missing entry (=faster). [don't] 
        errmargin N    during searches, re-check trees that are within 
                       N units of fit above best score. [0.5] 
        [no]autotune N during searches, compare estimated and actual  
                       scores of new trees, updating error margin 
                       With N=1 (=level 1), error margin is changed only 
                       within a given swapping cycle; with N=2, error 
                       margin is retained after swapping [level 1]. 
        maxtbr N       during searches using TBR, reroot clipped clade 
                       no more than N nodes away from original rooting 
                       (maxtbr 0 = SPR). [5] 
        setlim N       restrictpossible state-sets during optimization 
                       for characters with N states or more. [4] 
        maxdist N M    when restricting possible state sets, use union 
                       of states in branches up to N nodes away above a 
                       node, and M nodes below. [6-3] 
        [no]useminset  when restricting possible state sets, use a set 
                       corresponding to optimization under prior costs 
                       (very fast, very prone to errors. [don't] 
        maxrepeat N    when N successive branches have the same (unique) 
                       state, consider them as fixed. [8] 
        [no]quickrat   under this criterion, producing very few optimal 
                       trees, ratchet and drifting tend to find (and 
                       thus swap) the same tree many times; with this 
                       option, when the tree resulting from the perturbation 
                       phase of ratchet/drifting has the same score as the 
                       best tree(s) found so far, the tree is not swapped 
                       (this is applied only when auto-wt is ON). [yes] 
        backbuf N      back up N pre-existing trees during swapping; 
                       in case a tree is re-found, swapping is interrupted 
                       (prevents cycling due to score miscalculation; 
                       0 is no buffering). [0] 
        [no]verbose    as characters are optimized, report progress. 

    reserved for use by parent process, in parallel TNT 

    =N (name) [costs] 
        defines a step-matrix.  Syntax for costs is as in 
        "cost" command.  N must be a number 0-31.  Name is optional.  
    +name N 
        apply step matrix of specified name to character(s) N 
    ;   show defined step matrices 
    *   save them (to read, must set "nstates / num;") 

    N       sort tree(s) N, from best to worst 
    =nodes  instead of sorting by score, sort by number of nodes 
    =size   sort by number of taxa 
    =mono   sort by number of violated constraints 

    J K NxS  estimate number of SPR-swaps required to convert tree 
             J into tree K.  The method used is heuristic, depending 
             on random seed.  It does N replications, and reports  
             best estimation (if no N specified, then N=10); each of 
             the replications uses a "stratification" of up to S 
             levels (default S=0). Depending on the tree topologies, 
             the stratified procedure (more time-consuming) produces 
             better estimations. Using N+S instead of NxS, stratified 
             and regular procedures are alternated (keeping the best 
             overall values at the end).  If one (or both) of the  
             trees have polytomies, then the distance is calculated 
             (by default, see below) between the closest dichotomous 
             resolution(s). The "similarity" is number of moves  
             divided by number of taxa - 3 (i.e. max. possible moves). 
    *J K NxS estimate SPR-swaps and show moves on tree diagrams 
    [K;      count moves as weighted, with a move to D nodes away 
             costing D/(K+D).  As K decreases, approaching 0, all 
             moves cost the same; as K gets larger, longer moves are 
             more costly.  For reporting values, they're rescaled so 
             that the farthest possible move (nt-3) has a cost of 1. 
             Note that "[K;" only sets the value and type of compa- 
             risons to do in subsequent calls to "sprdiff" (or calls 
             to relevant macro expressions), without running. 
             Similarity is also obtained by dividing from number of 
             taxa minus 3 (i.e. max. possible number of farthest 
             possible moves, each of cost 1). The distance D of a 
             move equals degree of the polytmoy created when consen- 
             sing the trees before and after the move, minus 2. 
    ];       in subsequent calls to "sprdiff", count raw moves. 
    It is also possible to search for SPR paths such that no move  
    has a node connecting to one of its ancestors (if the SPR path 
    is to be interpreted as indicating horizontal gene transfer, 
    such moves constitute a physical impossibility). For this, use  
    ": noviol;" as argument ("viol" would allow such moves). 
    If you wish to count the moves needed to resolved/collapse 
    the polytomies of the tree(s), if any, then use ": poly;" 
    (keep in mind that this count is approximate!); default is 
    ": nopoly;". 

    NxR   set suboptimal to N, relative suboptimal to R (note: relative 
          suboptimal is measured against tree being swapped, not against 
          best tree(s) found).  Values of suboptimal used for subsequent 
          searches, or when collapsing trees with SPR or TBR. 

    J K  save text-buffer lines J to L to output file (default = all) 

    xxx<enter>  run xxx in system 

    =   use optional table format 
    -   use default table format 
    /N  use N significant digits for floating point values (default=2) 

    N;  set tag to N (parallel versions only) 

    -N;   de-activate taxon with number/name N (no N: show inactive taxa) 
    +N;   activate (no N: show active taxa) 

    N      report name of taxon N 
    xxx    report number of taxon named xxx 

    Handle taxonomy contained in the taxon names, in GB->TNT format 
    (i.e. symbol "@" followed by the categories, separated by under- 
      =     for subsequently read data sets, incorporate taxonomy 
      -     don't [ =default, uses less RAM ] 
      ;     if taxonomy has been incorporated, display it as a tree 
      /     display taxonomy as an indented list 
      +     store taxonomic tree as last tree in RAM 
      *T    label branches of tree(s) T which correspond to a taxonomic 
            group; extraneous taxa added to the group are indicated 
            as "+", taxa excluded as "-".  The criterion for  
            choosing closest group in tree (if any) is determined as 
            for "prunmajor" and "rfreqs" commands.  The tree list can 
            be followed by a list of categories, in the following format:  
                /L X-idae Z-idae 
                    processes X-idae and Z-idae (with L levels within) 
                    If L is followed by ">N", only subgroups of size N  
                    or more are further subdivided 
                \L B-morphae  
                    processes the subdivisions of B-morphae, up to L levels 
                    below B-morphae.  If L is followed by ">N", only groups 
                    of size N or more are further subdivided 
                    processes all the taxonomy categories containing "xxx"; 
                    if you want to make sure that "xxx" occurs at the end 
                    of the category, add an underscore (i.e. "xxx_"). 
            The options "/", "\", and "=" can be combined. 
      &T    as previous one, but results are output as a list.  The tree list 
            may be optionally followed by a list of the categories to report 
            (default=all; note categories are referred to by name, not number, 
            since numbering is only internal to TNT; the numbering follows 
            that on the taxonomic tree).  The command may end with "> A S", 
            where A and S are numbers of taxon-groups where to place taxa 
            added to the group, or subtracted from the group respectively, that 
            need to be removed to make the group monophyletic. Note that if the 
            symbol "&" is immediately followed by "?", then TNT asks  
            confirmation before placing taxa in groups. 
      |     similar to previous one, but only reports best/worst cases (instead 
            of reporting tree-by-tree stats), and output list is indented. 
      <T    shrinks the groups specified as in previous one (a single tree must be 
            specified in this case) 
      :T    color tree-branches for specified groups, on tree(s) T  
            For each tree colored, the colors are stored in tree-tags, which 
            can be saved in SVG format with "ttag & filename colors" 
            Each group to color can be given as:  
                /X-idae Z-idae  /A-idae  /B-morphae  
                    colors X-idae and Z-idae as state 0, A-idae as 1, and so on 
                    (the option to include a number of sublevels is ignored here, 
                     you must use "\" instead) 
                \L B-morphae  
                    colors the subdivisions of B-morphae, up to L levels below 
                    B-morphae, each with a different color.  If L is followed by 
                    ">N", only groups of size N or more are further subdivided 
                    colors all the taxonomy categories containing "xxx", 
                    each with a different color 
            The options "/", "\", and "=" can also be combined. 

      =          when referring to terminal nodes, use names 
      -          don't (=default) 
      /XXX N     rename taxa N as XXX (if XXX is *, rename at random; 
                 if XXX is > or <, switches name to upper or lower 
                 case, respectively). 
      +N         allow taxon names of length N 
      [N         on output, truncate taxon names to N letters.  Use "!" to 
                 truncate to species only (i.e. to "@" or cuadruple-underscore) 
      ]          don't 
      :T =G      re-locate list of taxa T in taxonomic group G.  This changes taxon 
                 names and re-processses taxonomy.  Optionally, group G may be  
                 followed by "+ _Supergroup_Group_Subgroup" --case in which 
                 the specified categories are added to the newly located taxa; 
                 or it may followed by "=C" or ">C", case in which all  
                 categories beyond "C" in the relocated taxa are preserved 
                 (exclusive, or inclusive, respectively).  The latter amounts 
                 to transferring an entire group (with its sub-classification) 
                 to a different higher group. 

    N   select tree N (use scopes, + and -) 
    /   select last memory tree, discard the rest 

    M N/L     show groups in tree M absent from N, excluding taxon (taxa) L 
    *M N/L    same, keeping tree as last memory tree 
    [         show only compatible groups 
    ]         show only contradictory groups 
    =N/M/L    calculate RI resulting from mapping the MRP of each tree 
              in set N onto each tree of set M, excluding taxon (taxa) L. 
              Note this is NOT equivalent to =M/N/L (RI is asymmetric). 
    &M N/L    plot tree N, showing for each group the equivalent group in 
              tree M (if none, "X"). 
    ! T/L     report PCR values (Pol & Escapa, 2009) for tree(s) T, taxa L. 
              if "=N" precedes list of taxa, then it reports worst N 
              values.  Using ">G" at the end, it puts listed taxa in 
              taxon-group G. 
    Note that the "=" and "&" options allow for taxon exclusion, but 
    never use temporary collapsing of unsupported groups. 

    Show duplicate trees 

    /S C T; create a new tree from trees S ("source") and T ("target") 
            inserting clade C of tree S into equivalent position of tree T 
            (clade C must be present in both trees; trees must be complete 
            and binary) 
    N   combine set of trees N, and add resulting trees to existing set of 
    Options (possibly preceded by "no" and defaults in parentheses):  
    For tree-fusing: 
       [no]equals       accept exchanges of equal score (don't) 
       [no]beststart    use best tree to start (use it) 
       [no]choose       choose only those exchanges that improve best score 
                        found so far (don't) 
       [no]repeat       for every individual fuse, re-fuse trees until  
                        no exchanges improve it 
       [no]swap         after exchanging clades, do TBR swap (swap) 
           minfork N    if node is less than an N-polytomy in consensus of 
                        both trees, skip exchanges (3) 
           rounds N     use N rounds (5) 
       [no]keepall      keep all trees found instead of best only (all) 
       [no]xroot N      for each fuse, try N different (random) rootings 
                        (N=0 is the default; it uses only outgroup as root) 
    For tree-hybridization: 
       [no]hybrid N*R/S instead of tree-fusing, use hybridization (as in  
                        "hybrid" command).  Hybridize randomly chosen pairs 
                        of trees, N times, for each round R.  Every round uses 
                        the best S trees from previous round to continue hybri- 
                        dizing.  Defaults: N 1000, R 1, S 50 (S = 0 uses as many 
                        trees as initially input, when doing several rounds.   
                        Works better than fusing for very unstructured data sets 
                        (e.g. random). 
       [no]autostop N   if N successive rounds of hybridization fail to improve 
                        score, stop (default = 3). 
       [no]replace      if hybridizing two trees produces a better tree, then 
                        replace source tree(s) with the better tree(s) 
                        (default = yes). 
       [no]clog N       If initial tree set increased to contain N times more 
                        trees than the initial input, retain best 1/N trees 
                        (default = 15). 
    For selecting type of genetic algorithm: 
       [no]picktype N   calculate a score for the expected outcome of fusing; 
                        this score counts the proportion of groups that could 
                        be exchanged between different pairs of trees in the  
                        input trees (when few or no groups can be exchanged,  
                        as is often the case for random data sets, tree-fusing 
                        produces very poor results). If the score so calculated 
                        is above N, use fusing, if below, use hybridization. 
                        The default is "nopicktype"; if "picktype" specified 
                        without a number, it uses the default threshold (1.5) 
                        Large thresholds preferentially choose hybridization, 
                        and viceversa. 
    Options are set with "tfuse:options;" or "tfuse=options;" (using 
    ":" only settings are changed; "=" runs as well). With "tfuse:;" 
    current settings are displayed. 

    Define group(s) of trees 
         "tgroup =N (xxx) J [K L M] len=X nod=X siz=X mono *R;" 
    places in group number N, optionally named "xxx," the tree(s) 
    subsequently specified with J (tree(s) number J), or in group(s) 
    K and L and M, or having a length, number of resolved nodes, or 
    terminals included, equal to X, or satisfying constraints, or R  
    trees chosen at random.  Symbol = can be replaced by > or < in  
    the case of len, nod, or siz. If the =N is replaced by >N or <N, 
    subsequently specified trees are added or removed from group N. 
    Several =N (or >N or <N) can follow a command; every one takes 
    into account previous ones.  Subsequent to definitions of tree groups, 
    group(s) of trees can be identified within scopes by referring to them 
    enclosing the group number/name in curly braces.  By default, trees 
    read or calculated are placed automatically in groups; this can be 
    toggled with "tgroup/;". To undefine group N, use "tgroup -N;". 
    Saving current groups is done with "tgroup*;".  The default 
    maximum number of tree groups (32) can be set to N with "tgroup+N;" 
    (this must be done prior to reading the data). Whether newly 
    read or created trees are automatically added to tree groups is 
    toggled with / (default is on), or set to a specific value with 
    "tgroup [no]auto". 

    show acknowledgments 

    set timeout for searches (hh:mm:ss) 
    In Linux versions: if running in the background, creating a 
    file "stop_tnt_ID" in the working directory automatically 
    sets the timeout for searches to 1 sec., thus interrupting 
    all searches. 

    N   count nodes in tree(s) N 

    N    show tree(s) N. 
    *N   show tree(s) N in parenthetical notation. 
    /    show only last tree in memory 
    +    draw trees more symmetrically (they're taller!) 
    -    draw trees with default format 
    If + or - are followed by + or - this turns on (+) 
    or off (-) whether second heaviest clade is drawn 
    first in polytomies. 

    read tree(s) in parenthetical notation; semicolon ends; 
    '*' separates trees.  Using "=N" (or ">N") as first argument, the 
    trees are placed in (or added to) group N. 
      The tree-definition can be done using taxon names or numbers 
    (if using a name, the first taxon matching the name is used). 
    Alternatively, a string followed by three periods (no spaces in 
    in between) will place in the corresponding location all taxa 
    whose name matches the string provided.  Also, using @T N will 
    place all the taxa that belong to node N of tree T in the corres- 
    ponding location.  Using a + instead of the @, the sub-tree N 
    of tree T is copied (and then this is just one node, so make 
    sure you don't enclose +T N within parentheses, which causes an 

            open tree files (with + at the end, append) 
    xxx     open in compact (default) mode 
    *xxx    open in parentethical notation, using taxon names 
            or numbers (see under "taxname") 
    /       close tree file 
    !t xxx  autosave results to file, every t seconds (t can be given 
            as hh:mm:ss).  For maximum safety, results alternatively saved 
            to files xxx-1 and xxx-2 (if power fails when saving, the 
            previous one remains). 

    Define groups of terminals to shrink tree. Usage: tshrink =N name list ; 
    Replacing N by "+" names next available group of taxa.   Symbols  
    "]" and "[" deactivate/activate subsequently specified shrinks; 
    symbol "-" undefines them.  "Tshrink*" saves subsequently specified 
    tree(s) in parenthetical notation, but shrinking internal nodes. 
    Shrinks may use a lot of memory (specially in large data sets).  If 
    you want memory for shrinks to not be allocated, use "tshrink !;" 
    before reading the data set ("tshrink +" will allocate the memory). 

    N   count number of taxa included in tree(s) N 

    ;       show tree tag(s). 
    =       store tree tags for subsequent tree printing command(s) 
            (first tree printing command sets the target tree) 
    (       synonym of "=" 
    )       stop storing tags (but don't erase them) 
    -       clear all existing tags 
    +N txt  write txt to node N of target tree 
    <N      erase (i.e. reduce to a minimum) tree-tag for node N 
    *N      set tree N as target tree (no labels written). Using 
            "!" instead of "*N" the last tree is used 
    /;      save tags in a readable form 
    [       separate tags in new lines, using "\" as separator 
            for each legend (only in graphic trees) 
    ]       don't 
    &xxx    save tree-tags as tree diagram, in SVG (Scalable Vector 
            Graphics, XML) format, to file "xxx".  File name  
            may be followed by: 
               blength N    branch span (width) 
               bheight N    branch height 
               thickness N  branch thickness N 
               colors       save as colors.  In this case, the color 
                            is determined by the first digit in the tree- 
                            legend; more than a single digit (or a non-digit) 
                            colors the branch as gray (=ambiguous).  A text 
                            can also be displayed, if the color code is  
                            followed by a forward slash and text. 
               fontsize N   use a font size of N 
               pendwidth N  use a font of stroke N (=boldness) 
               txtsep N     if using multi-line legends, separate lines 
                            by N points 
               legup N      raise branch legnds by N points 
            The resulting SVG file can be opened with any appropriate program 
            (including most web browsers: Firefox, Opera, Safari, Chrome). 
            Color codes (from 0 to 9) are red, blue, green, cyan, brown, pink 
            orange, purple, magenta, and yellow.  Instead of these color codes, 
            it is also possible to indicate RGB codes (in parentheses, separated 
            by commas, optionally followed by a fourth number indicating branch 
            thickness before closing the parenthesis). 
    NB: thanks to Salvador Arias for showing me the SVG format! 
    NB2: If you wish to display a text in a specific color (with 0-9, IUPAC 
         codes for DNA, or RGB codes), then precede the text by a forward 
         slash and precede the slash by the color code. 

    N     set size of display buffer to N Kb 
    ;     report buffer usage 
    =     set buffer to compressed mode (slower viewing; default) 
    -     set buffer to uncompressed mode (faster viewing) 
    /     report approx. amount of disk space needed for text buffer 

    X Y  insert groups of tree X onto tree Y 

    xxx  view file xxx 
    +    auto-view text-buffer on 
    -    auto-view text-buffer off 
    ;    view text-buffer (text-buffer has all the output).  Arrow keys 
         move buffer.  Pressing ":" followed by a string, the string 
         is searched in the text-buffer (& repeats). 
         While in viewer: 
             -   up one line 
             +   down one line 
             o   up one screen 
             p   down one screen 
             e   end  
             h   home  
             l   left half a screen  
             r   right half a screen  
            ESC  exit buffer viewer 
    See also txtsize, svtxt. 

    show version 

    =   issue warnings 
    -   don't (default) 

    =   time execution of commands 
    -   don't (default) 
    [  in addition to time, measure RAM (bytes) used by each command 
    ]  don't (default) 

    N    compare fit, character by character, between reference tree and 
         tree(s) N.  Must have defined a tree as reference, with "xcomp =X." 

    define character group(s).  Syntax is as in "tgroup" (but options "len",  
    "nod", "siz", or "mono" are not allowed, option "/" automatically 
    creates a group with each data block, and "xgroup !;" saves only) 
    active characters) 

    Deactivate all uninformative characters in matrix 

    Run multiple replications, using sectorial searches, drifting,  ratchet 
    and fusing combined.  Options are: 
      hits N             produce N hits to best length and stop 
      replications N     for each hit, search initially with N replications 
      [no]targetscore N  search until score N found (only with fusing) 
      [no]update         do not update targetscore 
      [no]giveupscore N  give up search as soon as score N found 
      [no]rss            use random sectorial searches (settings with 
      [no]css            use constraint sectorial searches (settings with 
      [no]xss            use exclusive sectorial searches (settings with 
      [no]fuse           use fusing (settings with tfuse:options) 
      [no]gfuse N        every N hits, fuse all trees (=score check) 
      [no]dumpfuse       if fusing fails to produce trees of target score, 
                         dump the trees produced by fusing (may prevent 
                         "clogging" of subsequent fuses by keeping only the 
                         most distinct trees) 
      [no]rebuild N      use N cycles of rebuilding (other settings with  
                         "rebuild: options;"). 
      [no]drift N        use N cycles of drifting (settings with drif:options) 
      [no]ratchet N      use N cycles of ratchet (settings with rat:options) 
      hold N             for ratchet, drifting, or rebuilding, save up to N 
                         trees per initial replication (default = 1). 
      [no]autoconst N    use consensus of previous run and initial stages of 
                         current as constraint for initial stages. 1=previous 
                         and wagner, 2=previous and SPR, 3=previous and TBR.  
                         The first replication of a new hit is never 
                         constrained (i.e. hits are totally independent). 
                         Note that level=2 defaults to 1 when "skipspr" 
                         is on. 
      [no]xmix           after unsuccesful fusing, start a new set of  
                         replications as autoconstrained (otherwise, don't) 
      [no]prvmix         if trees existed in memory before running xmult, use 
                         last one to autoconstrain first xmult replication 
      [no]consense N     consense untill consensus is stabilized N times 
      conbase N          base hits to check for consensus stabilizations 
                         (larger numbers make more reliable estimations) 
      confactor N        factor to increase number of hits to check consensus 
                         stabilization (10-100, larger numbers: more reliable) 
      conmax N           maximum new hits to recheck consensus (default=12) 
      [no]keepall        keep trees from all replications.  This has a different 
                         meaning when "hits" is 1 (=default) and when "hits" >1. 
                         When "hits" = 1, it is trees from each of the RAS + TBR + 
                         SS or DFT or RAT, in addition to the trees resulting from 
                         fusing those.  When "hits" > 1, then it means the trees 
                         resulting from fusing the initial starting trees for each 
                         of starting points.  Thus, to find N trees, each resulting 
                         from S starting points (RAS+TBR+etc) and fusing, use 
                         "xmult = hit N noupdate rep S keepall". 
      [no]retouch N      before trying new replications, repeat sectorial 
                         search and ratchet/drifting 
      level N            set level of search (0-10). Use 0-2 for easy data 
                         sets, 2-5 for medium, above 5 for difficult 
      chklevel N         check search parameters during run, every N hits. 
                         The parameters are increased or decreased, starting 
                         from user settings.  If N is preceded by +F (between 
                         0 and 2), the entire level is changed by F. If N is 
                         preceded by -, user settings are starting point 
      [no]multiply       after hitting target score, find additional trees by 
                         fusing suboptimal with optimal trees (default = yes). 
      [no]verbose        produce verbose reports 
      [no]hybrid         use hybridization; this can be used jointly with  
                         tree-fusing.  Number of hybridizations, rounds, sample 
                         size, and unsuccesful rounds to stop, are set with 
                         the "tfuse" command.  When combined with "picktype", 
                         a number x F can follow "hybrid" --this is the factor 
                         to multiply the number of replications if "hybrid" is  
                         chosen instead of "fuse".  Fusing normally needs fewer 
                         trees as input (it is for more structured data sets), but 
                         when "pick" is used, genetic algorithm is determined at 
                         run time, thus user cant't predict ahead of time which 
                         genetic algorithm will be used.  As example, with "pick  
                         hybrid x4 repl 5", if fusing is picked, then it will use 
                         (initially, at least) 5 replications for fusing; if  
                         hybridization is picked, then it will use 20 replications. 
      [no]picktype N     use either fusing or hybridization, choosing with  
                         threshold N (see under "tfuse"). This uses only one 
                         type of genetic algorithm; if you want both to be used, 
                         just set them both.  If using "verbose", then choice is 
                         indicated on screen. 
      [no]hfuse N        every N hits to minimum length, hybridize all resulting 
                         trees as an extra check for optimality. 
      ras,cas,ias,       select type of addition sequence for the Wagner trees (if 
          sas,fas        not specified, the one last used with "mult" is used). 
    Options are set with "xmult:options;" or "xmult=options;" (using 
    ":" only settings are changed; "=" runs as well). With "xmult:;" 
    current settings are displayed.  If consensing, / followed by a taxon list 
    removes the specified taxa from the consensus (this must follow all the 
    other options).  If css, rss, and xss are specified css is done first, 
    then rss, and xss last.  Rebuilding, ratchet, and drifting (in that order) 
    always follow sectorial searches.  Global hybridization and/or tree-fusing 
    are done last (although they may be done as part of rebuilding, ratchet,  
    or drifting). 

    N/L;   permute states within character(s) N, for taxa L 
    -;     undo last permutation 

    Handle options for extended implied weighting 
      -    set extended options OFF 
      =    use extended implied weight (use character sets for constant 
           or "set weighting", and/or different weighting strengths for 
           different characters). Character sets defined with "xpiwe[" are  
           weighted using average homoplasy in the set.  For a set of N  
           characters with total homoplasy H, the score for the set is 
                              N * ---------  
                                  (H/N) + k  
           Sets defined with "xpiwe/" have constant weight. Note that set 
           weighting is peculiar in making parsimony-uninformative characters 
           relevant to the analysis; for set weighting, when user-defined 
           weighting functions are in effect, TNT needs to extrapolate costs 
           (since it uses average numbers of steps). When combining different 
           weighting strengths in an analysis, the fitting function for all  
           characters is rescaled so that the first extra step (i.e. no  
           homoplasy) costs the same for all characters.  
           NOTE: extended implied weighting is valid only under "piwe=",  
           not "piwe+", and to apply it you must read the data with  
           implied weights turned ON.  
      /    define a set of characters with constant weight.  Usage is:  
           /NxF L, where L is the list of characters for which every step 
           costs the same as F times the cost of adding 1 step to a 
           character with N extra steps (under the "base" concavity,  
           or the user-defined weighting function). 
      [L   define a set of characters (L) for homogeneous "set weighting".   
           If L is (optionally) followed by "=N", then the set L is 
           divided in subsets or "chunks" of N consecutive characters  
           each.  If L is followed instead by "/" and a partition  
           (e.g. in the form "12:3" or "1:2:3") then the first, 
           second, and third positions within list L are grouped. Not 
           specifying 1, 2 or 3 leaves those positions outside the subset(s). 
           NOTE: when user-weighting function are in effect, weighting-sets 
           require calculating fit for fractional (i.e. non-discrete)  
           numbers of extra-steps; this is done by interpolating (on 
           the fitting function assembled from the user-defined cost 
           function) using the same interpolator of the macro expression  
      ]    like previous one, but it does all data blocks automatically 
           (e.g. "xpiwe]/12:3;" creates a set for 1st and 2nd position, 
           and another with 3d, for each of the data blocks, while  
           "xpiwe]=10;" divides each of the data blocks in chunks of  
           10 characters each) 
      *    write to log file the list of characters in weighting sets,  
           and the list of characters with fixed weights, in a format  
           readable by TNT 
      &L   report status of weighting sets for tree(s) in list L.  If list 
           preceded by strings "steps", "score", "homoplasy", or  
           "size", then it reports the corresponding value (default is 
           "size").  Under different concavities, you can also report 
           the concavity values of each set ("kvalue") or cost of adding 
           a step to an average character in the set ("cost") 
      !L   remove characters in list L from weighting sets and from the set of 
           characters with fixed weight. 
      (    handle implied weighting with different concavities for different 
           characters. The symbol "(" can be followed either by "*" or by 
           a list L of characters.  The "*" (see below) determines different 
           weighting strengths based on numbers of missing entries; with a  
           list L, the user defines the concavity for the characters  
           specified in L.  N.B.: the values of concavities (or the cost  
           of adding steps for the different characters) are shown by the  
           "piwe&" command, not by this one. 
           (* Option:  
              This option is intended to address the problem that characters  
              with many missing entries cannot have much homplasy, and thus  
              normally have high implied weights during analyses. With  
              "( *P <M /K", missing entries are assumed to have (for the  
              purpose of calculating fit differences) a proportion P of the  
              homoplasy which occurs in observed entries .  Thus, if P is 1  
              and half the cells in a character are missing entries, the cost  
              of adding a step to a character with H extra steps is (approxi- 
              mmately) the same as the cost of adding a step to a character  
              with 2H steps. If no P is specified, the default (0.5) is  
              used.  The approximmation used with the default weighting  
              function is based on using different K values, given that for  
              the standard weighting function, the cost of adding a step to  
              a character with N extra steps, under K1, is approximmately the 
              same as adding a step to a character with N.K1/K2 extra steps  
              under concavity K2.  Thus, characters with more missing entries 
              get lower K values (i.e. they decrease their influence more  
              quickly as homoplasy increases, but are equally influential in  
              the absence of homoplasy).  M determines the maximum acceptable  
              ratio between K1/K2 (1<=M). If no M is specified, the default  
              (5) is used.  The value K determines the "base" concavity (i.e.  
              the concavity for a character with no missing entries); if "/K" 
              not included, general concavity is used.  Note that P=0 or M=1  
              are equivalent to standard implied weighting.  If weighting sets 
              have been defined (with the "xpiwe[" or "xpiwe]" options), TNT 
              will honor those sets (extrapolating from the average homoplasy 
              in the observed entries to the total missing entries in the set).  
                 When a user-defined weighting function is in effect, then the 
              K values are used as factors for extrapolation to missing entries 
              (a character with concavity K, under general concavity G, is 
              considered to have G/K times the homoplasy observed in the 
              non-missing entries).  Remember, this means that the cost of 
              adding a step to a character with S steps is the same as the cost 
              of adding a step to a character with G/K times the observed 
              homoplasy, not G/K times the step cost!  The interpolator uses 
              the cost function defined by the user (not the fit function  
              assembled from it; note that the two options might produce  
              slightly different results).  
           (L Option:  
              with "(L /K", all the characters in list L get concavity K.  
              Initial concavities can be set with the previous option, and  
              then modified with this one (case in which TNT will honor the  
              last set of concavity values determined by the user). Keep in  
              mind that if weighting sets have been defined, all the  
              characters in a set must have the same concavity!  When user- 
              defined weighting functions are in effect, k is used (as in the 
              previous option) as a factor to extrapolate. 
      )    use a single concavity (or user-defined weighting function) for  
           all characters.  

    Read data; Hennig86/NONA format. Interleaved: each block preceded by "&" 
    and block options within square brackets.  Block options are: 
       continuous     continuous 
       dna            DNA data  
       proteins       aminoacid data 
       numeric        alphanumeric data 
       landmark 2D,3D read two- or three-dimensional data (landmark coords.) 
                      Each "character" can consist of several points; use 
                      "|" to separate characters, and ? for missing. 
       gaps/nogaps    read gaps as fifth state / missing 
       trimhead       if data are DNA or AA, and gap is fifth state, 
                      make all leading gaps missing entries 
       trimtail       likewise, for trailing gaps 
       match N        consider names of similarity N, as the same 
                      the same taxon (with 1 identical) 
       verbose        give stats for each block 
    Editing data: 
         =C T S  set states for taxon T, character C, to set S. 
                 If T is within square brackets, then it can be  
                 a list of taxa. 
         =!C T S same, but do not re-check minima-maxima (saves 
                 time, but unless "xread ==;" is used, subsequent 
                 optimizations may be wrong.  Use with caution!) 
         ==      check informativeness for all characters (=undoes 
                 possible side-effects of previous one). 
    Saving data: 
         *       all chars.  (followed by "*" also saves char. settings) 
         -       only active  (followed by "*" also saves char. settings) 
         [       only active, randomizing order of characters (=mangling) 
         !T/C    save only taxon names and chars. (no xread, no ccode), 
                 for taxon list T, character list C (default=all). 
                 If list T preceded by "(N)" (where N is a tree-number), 
                 then T may contain a list of HTU's for tree number N. 
    Generating data:  
         /C T N;   random data with C characters and T taxa (each of N states 
                   equiprobable at each cell) 
         +T P C N; Neyman/Jukes-Cantor data, using tree T as model, probability 
                   of stasis P, C characters, and N states.  If P = 0 , then it 
                   assigns branch lengths at random. If "T P" is replaced by 
                   "!", then branch-lengths in tree-tags are used (and tag-tree 
                   is used as model tree). 
         >T P N L  as previous one, but L is the list of characters to generate. 
                   ("T P" can also be replaced by "!"). 

    Remove data set from memory (allows changing settings) 

        discard duplicate trees (without collapsing) 
    *   collapse first and then discard duplicates 

    =   prune unshared taxa from trees when calculating consensus (default) 
    -   don't 

    N =M  set minimum number of steps for (sankoff) character(s) N to M 
          (if 0, turns user-minimum off for the character(s) specified). 
    +N    set maximum number of states for all sankoff character(s) N to M 
          (in optimization, try those states even if absent in terminals). 
          This does NOT apply to sankoff characters which correspond to a  
          character-state tree, which always use the actual maximum. 

       Go to sleep!! (=quit) 

    Generate all trees, and execute [commands] for each one 
    Syntax is:  

         bandb   [ commands ] ; stop  

    The trees generated include intermediate trees; the generated 
    tree is always the last one in memory (if no trees existed when 
    bandb started, then tree 0).  The tree can be modified or copied 
    onto other trees with [commands].  After bandb finishes, it leaves 
    a polytomous tree as tree 0 if bandb started without trees, or as  
    the Nth tree if N trees were in memory (this is done so that  
    tree-numbers continue being the same as within bandb). 

    Within bandb, the following commands are recognized: 

       cutbranch    don't continue descending into search tree 
       continue     skip subsequent instructions for this tree 
       endbranch    interrupt process 

    When running bandb, variables percswap, bbfull, and bbtax 
    are recognized. 

    Enter a loop, enumerating combinations. Syntax is: 

         combine X min/max varname  ...   endcomb  

    which enumerates the combination of min out of X elements, 
    then min+1 out of X, min+2 out of X, ... max out of X.  If 
    "/max" is ommited, then max = min.  The elements are written 
    to variable "varname" (must be an array), and listsize equals 
    number of elements minus 1 (keep in mind that listsize can be 
    subsequently modified within the loop, make sure to store value 
    at the beggining of loop if this is so). 
    Note: maximum possible recursion of "combine" is the same as 
    for "travtree" and "iterrecs". 

    skip to next loop iteration 

    X Y;    copy tree X to tree Y (if no Y is specified, tree 
            X is added as last memory tree). If the first tree is 
            specified as *, then the constraint tree is copied; if 
            as +, then tagged tree is copied. 
            Note:  with the "[" option, if taxonomy is enabled, 
            and a tagged tree exists, then the tags in tag-tree are 
            copied onto the taxonomy; this options also modifies 
            taxon names, so as to contain taxonomy (at least, within 
            available space for taxon names).  Note that this option 
            will collapse untagged nodes in the tagged tree (since 
            they represent no category). 

    Check for user interrupt 

    in bandb, don't descend into search tree 

    execute subsequent block of instructions when preceding IF not fulfilled 

    finish an IF block 

    terminate bandb 

    terminate loop 

    terminate swapping 

    xxx;   call error handler with error xxx 

      Loop, for all filenames matching a given string, executing command(s). 
      Syntax is:  

         forfiles fname  ... command(s)...  stop  

      this will run "command(s)" for all file(s) matching "fname". 
      Within "forfiles", the string "killfiles" interrupts subsequent 
      iterations, and "proc/;" terminates current iteration. 
      The current file is retrieved with "$curfile"; "curisdir" indicates 
      whether current file is a directory.  If you need to indicate spaces  
      within "fname", use the "^" symbol (just like file names in other 
      contexts).  Note that file names containing symbols used as sigils  
      for scripting (symbols ', ", $, or #) are skipped. 

    fname L [args];   goto file "fname", and start parsing from 
                      point labeled L (with "label L;") 
    =fname;           define "fname" as default target 
    -;                undefine default target 
    [fname L;         define "fname" and "L" as the file 
                      and label to parse AFTER an error/break. 
                      This is intended mostly to allow writing 
                      exit codes for graceful script termination. 

    Handle input files (for parsing). 
     =N;               set maximum number of open input files to N. 
     open xxx          open file xxx (can open several at a time; last) 
                       one is set as "active" file). 
     active xxx        set file xxx as active file. 
     list              list open input files. 
     close [xxx ]      close file xxx (if unspecified, close 
                       active input file). 
     skip [xxx ] N     skip N bytes (default=1) from file xxx (if 
                       unspecified, active file). 
     skipline [xxx ] N skip N lines from file xxx (if unspecified, 
                       active file). 
     seek [xxx ] C N   read from file xxx (if unspecified, active 
                       file), until character C found (&N=ASCII N), 
                       N times. 
     skips [xxx ] N    skip N strings from file xxx (if unspecified, 
                       active file). 
     seeks [xxx ] S N  find string S in file xxx (if unspecified, 
                       active file), N times. 
    Note that "open" and "active" (which must be given a file 
    name) do not use square brackets around file name, while the 
    other options (for which file name is optional), require brackets. 
    Except for setting maximum number of input files, the other options 
    can be combined together (a semicolon ends execution of hifile). 
    See also expressions hifline, hifchar, hifstring, hifnumber, hifeof. 

    Take decisions.  Expressions are as in C, but with 
    precedence always evaluated from left to right, for 
    all operations/comparisons.  Use parentheses to change 
    precedences.  Operators: + - * / and bitwise AND/OR/XOR (&|^) 
    Comparisons (==, !=, >, <, >=, <=) take on value 0 or 1. 
    Use && and || for logical AND/OR, and ! for negation. 
    Every IF must be matched by either END or ELSE. 

    Loop over reconstructions of a character, writing states to an 
    array.  Syntax is:  

               iterrecs T C rayname (actions) ; endrecs  

    For every reconstruction of character C on tree T, this stores 
    the values on array "rayname" and executes action(s).  
    Within iterrecs, 'rayname[N]' automatically returns number of 
    state (as a number, not as a bit set; this is different from  
    the "states" expression).  If name of array is preceded by &,  
    then in case a cell (=node) in the array is different from  
    "missing", it considers only reconstructions having that 
    state at that node (if the value is positive or 0), or only 
    reconstructions not having that state (if the value is negative; 
    to forbid state 0, set the value to a negative number between  
    0 and -1, which gets rounded as "-0").  Note that states can 
    be forbidden only for discrete characters. 
       When reconstructions are too numerous, it is possible to take 
    a random sample of no more than N reconstructions (where each 
    reconstruction is equally likely to be sampled), using "/N" 
    before the name of the array. 
       If character C is continuous, it can be followed by "*D", 
    where D is the increase between reconstructions (otherwise, 
    the interval limits are used).  Using "+" instead, the values 
    written in the array are the (signed) differences between ancestor 
    and descendant for each node (as in blength > or <). 
       Within iterrecs, the string "killrecs" interrupts execution, 
    and expression "recsteps" returns the cost of the reconstruction 
    (if forcing states, this may be larger than minimum length). 
    The command iterrecs can be nested (maximum level of nesting can 
    be set with iterrecs = N; default is 5). Nesting iterrecs may 
    require that "mxproc" is reset as well. 

    Skip subsequent iterations of "forfiles" command 

    N;     mark point as label (see "goto"). 

    Do a loop, of the form:  

              loop X+Z Y  (actions)  stop 

    this repeats (actions) from X to Y, increasing (or  
    decreasing) by Z (default Z = 1).  The expression "#N" 
    is replaced by the value corresponding to Nth loop.  An 
    alternative syntax is:  

              loop = loopname X+Z Y  (actions)  stop 

    case in which "#loopname" is equivalent to the value of 
    current iteration. The default maximum number of nested  
    loops allowed is 15, but it can be changed with macro* to  
    any number. 

    Determine floating-point options for macro language 
    =;        floating point calculations enabled 
    -;        use only integer calculations (saves memory space, not speed) 
    N;        if floating point enabled, uses N decimal digits when printing 
              floats (0 uses no digits; equivalent to integer only, but 
              uses more memory) 
    e;        if floating point enabled, use exponential notation 
    *;        if floating point enabled, use default printing mode 

    =        activate macro language 
    -        deactivate 
    *K N     re-set max. number of loops as K, user variables as N 
    [N       re-set memory to be used by macro language as N (KB) 
    +        in macros, read taxon/character names as numbers 
    !        don't read taxon/character names as numbers 
    prot N   set protection level for macros as N 
                0  no protection 
                1  check whether accesses to arrays are within dimensions 
                2  prevent re-assembling of multidimensional arrays by user 

    =     inform results of comparisons/assignments during macros (=debugging) 
    -     don't (default) 

    N   set seed for random number generator for macros 

        Followed by number/name of one-dimensional array, displays in a table 
        the values for the array (copying everything from the array name to a 
        semicolon into the table title).  If title preceded by "=N", then it 
        displays up to N values in the table.  Using '*' as first argument, 
        it displays two arrays in a combined table.  Maketable is illegal when 
        macro protection is off; combined tables are illegal when floating 
        point is enabled.  Only values >= 0 can be displayed.  In double 
        tables, if one array has more values than the other, the invalid cells 
        are displayed as "0." 
           Maketable can also be used to copy values from tables to arrays: 
        with "maketable + varname;" subsequent invocations of any command 
        which writes (single valued) tables will store the values in array 
        "varname".  Variable "listsize" contains number of values written 
        to array minus 1.  Use "maketable -;" to subsequently turn this off.  

    N;     keep N variables (besides named ones) as private 

    create/update progress bar. Usage: progress j k text, where 
    j= done, k= to do, text= everything until a semicolon is 
    found.  Always must close progress bar with "progress/;" 
    Report can be "refreshed" with "progress=;". 

    recursively call the input file being parsed (arguments 
    to "recurse" are passed to the input file) 

    save current rearrangement and re-start swapping  
    (valid only within tsprit or tbrit commands) 

    re-set time for macros 

    N;     set value of internal variable "exstatus" to N  

    xxx N ;  string xxx can be "vars,", "loops,", or "ram"; it checks 
             whether N variables, loops, or bytes for macro are free, and 
             reports an error otherwise 

    Set value of user variables 
      N    set value of variable N to subsequent expression. 
      N $  set variable N as string (semicolon ends). 
           Fixed strings (output only): $dataset, $taxon N, 
           $character N, $state N S, $block N, $agroup N,  
           $tgroup N, $xgroup N, $bitset N, $dnabitset N, 
           $taxonomy N, $curfile, $ttag N, $hifstring, $curwd 
           and $host N. 
      +    when converting strings (with $varname), add a blank 
           at the end. 
      -    don't. 

    J,...,K,L  XXX  
           set all cells of variable XXX, of dimensions Jx...xLxK (expression 
           must be followed by Jx...xKxL values, ending with a semicolon) 

    N;     reset loop to N 

    Get variables from slaves.  Syntax is:  

           slaveget [ J T ] mmm ttt ;  

    this copies the results from variable ttt in task T of job J 
    onto variable mmm of master.  If no task is specified, the 
    values from ttt on task i are copied onto mmm[i] (or the 
    corresponding section of mmm, if subindices had been indicated 
    for mmm itself, case in which in the number of dimensions 
    in mmm and ttt must match.  In the subindices of ttt, user 
    variables enclosed in single quotes (') are interpreted locally, 
    in double quotes ("), interpreted in slave. 

    [J T]    set variable in slave T of job J (syntax as in set; 
             no T = all tasks of job J).  User-variables enclosed in 
             single quotes (') are interpreted locally, in double 
             quotes ("), interpreted in slave. 

    "sprit N (commands) stop" does SPR to tree N, executing "commands" 
    for each rearrangement (see also resetswap, endswap) 

    "tbrit N (commands) stop" does TBR to tree N, executing "commands" 
    for each rearrangement (see also resetswap, endswap, continue) 

    Loop, travelling a specified tree, T. Syntax is: 

          travtree type T N varname (actions) ; endtrav  

    in every cycle, the number of node visited is written onto 
    the specified variable. Type can be one of four:  

      up    travels tree in an unpward pass, from node N; if "up" 
            is followed by the string "terms" it also does terminals, 
            otherwise it doesn't 
      down  travels in a down pass, towards node N, terminals never 
      below travels from node N towards root 
      path  travels from nodes N1 to N2 (two nodes instead of one  
            must be specified for "path") 
      des   visits all immediate descendants of node N 

    The variable can be preceded by a minus sign (-), case in which 
    node N itself is not included in the list.  Within travtree, 
    the command "killtrav" ends current travelling, and (in the 
    case of up-passes) the command "skipdes" excludes all the 
    descendants of current node from the loop. 
    Note that the order in which nodes are travelled in scripting  
    commands may not agree with the sequence with which nodes are 
    plotted in tree diagrams.  If you want to make sure that scripts 
    use the same sequence as in plotting, turn this option ON with  
    "travtree +" (OFF with "-"). 

    N;       report name and value of variable N (no N = all vars.) 
    /N;      same, using bits (up to 30) 
    = N XXX; name variable number N as "XXX."  Replacing the N by a '+' 
             names the next variable. Variables cannot be renamed, but 
             variables named within a file can be denamed with '-'.  This 
             allows variables to behave as "static" within a file.  If 
             several variables have identical names, using the name 
             accesses the last one named (e.g. in the current file). 
    :        name variables, using a looser format than with =.  All that 
             is neded here is a list of names (and their dimensions). 
    -N;      dename all variables above N (no N = all variables named from 
             within the current input file. 
    N;       if N is defined as an array, report all the values in the array 
    N*;      same, saving in "setarray" format (readable by the program) 
    +        display a (very simple) graph with the values of two arrays. 
             Syntax is:  
                  var + X [ minx maxx] Y [ miny maxy ] array_A array_B ;  
             X is the number of spaces to use on X-axis, Y is number of  
             lines to use on Y-axis; minx and maxy are starting and end 
             points of X axis, likewise for Y (if unspecified, min/max 
             values in the array are used). Array_A and array_B are names 
             of (one-dimensional) arrays; the graph plots array_B[i]  
             against array_A[i]; if array_A doesn't have the same number 
             of values as array_B, then the minimum number is  
             used; if array_B is not specified, then the graph plots 
             array_A[i] against i (for each of the values in array_A). 
    &X Y     linear regression of variables X and Y (must be arrays). If 
             *W follows Y, then weights in W are used. Weights must be 
             between 0 and 1 (if some weights exceed unity, all weights 
             are rescaled; having a point of weight W is equivalent to  
             having W points with those coordinates instead of one). If 
             a number N follows after the arrays, then only the first 
             N values of the arrays are considered in the regression.
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License