ABSINCL
    =   in tread, send excluded taxa to tree base 
    -   exclude them from tree 
 
AGROUP
    define groups of taxa.  Syntax is as in "tgroup" (but options 
    "len", "nod", "siz", or "mono" not allowed, and  
    "agroup !;" saves only active taxa) 
 
ALLTREES
    generate all trees for active taxa 
 
ANCSTATES
    N   define character(s) N as ancestral. Ancestral 
        states correspond to those of current outgroup 
 
APO
    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 
 
BBREAK
    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).  Options are: [no]mulpars, spr, tbr, 
    [no]fillonly, clustersize N, [no]safe, [no]skipspr.  This swaps  
    according to current setting of suboptimal, constraints, and 
    collapsing. The "nosafe" option uses a faster method for updating 
    buffers when finding a better tree under TBR, but this is not well 
    tested yet and it might have errors (default is "safe"). The  
    "skipspr" is useful in conjunction with "nosafe", because then 
    starting each replication with SPR is counter-productive (TBR 
    reaches equivalent scores faster). The "nosafe" option only makes 
    a difference for very large data sets; "skipspr" modifies the 
    behavior of both "mult" and "xmult".  NOTE: with "preproc" 
    the program tries to identify and move 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. 
 
BEEP
    =   beep on errors and warning messages 
    -   don't (default) 
 
BEST
    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 
 
BGROUND
    as first argument when calling TNT, it tells it to run in background 
 
BLENGTH
    N;    show table with branch lengths for tree(s) N 
    *N;   same, using a tree diagram 
 
BLOCKS
    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) 
 
BREAK
    =   enable breaks with <esc> or '.', pauses with 'p' (default) 
    -   don't 
    /   copy text (ending with semicolon) to display as warning if 
        calculations are interrupted ("yes" interrupts anyway) 
        By default, interruption produces no queries 
 
BSUPPORT
    Calculate bremer supports, using trees currently in memory. 
    =N    collapse groups with support < N 
    N/L   use tree(s) N, pruning taxon (taxa) L, and display results 
    *N/L  same, but save tree as last tree in memory 
    [     use relative (instead of absolute) supports 
    ]     use relative supports, using only trees within absolute support 
 
CCODE
    !  re-sets ccode to the one defined in the data file 
    Other than that, sets character codes.  Specifiers are: 
         +   make following character(s) additive 
         -     "      "         "        non-additive 
         [     "      "         "        active 
         ]     "      "         "        inactive 
         (     "      "         "        Sankoff 
         )     "      "         "        non-Sankoff 
         /N   apply weight N to following character(s) 
         =N   apply N additional steps to following character(s) 
 
CDIR
       change directory 
 
CHANGE
    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 
 
CHOMO
    N   show homoplasy (=extra steps) for tree(s) N 
 
CKEEP
         set current ccode as default 
 
CLS
    Clear screen 
 
CLBUFFER
    ;      clear text buffer 
    *     clear command buffer 
 
CNAMES
           name character(s) / state(s) 
    *;     save character names 
    !;     save character names (active chars. only) 
 
COLLAPSE
    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. 
 
COMCOMP
    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 
 
CONDENSE
    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) 
 
CONSTRAIN
    =   Re-inforce constraints for mono- and non-monophyly 
    -   don't (default) 
 
COSTS
    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 
 
CSCORES
    N/L   report length/fit for character(s) L on tree(s) N 
 
CSTREE
    N = [cst]  read character state tree (=costs) for char(s) N. 
               Type cst after a carriage return, with symbols /\-| and X. 
 
DMERGE
    dmerge OUT =DIR IN1 IN2    merges files in1 and in2 (from directory dir) 
    dmerge*;     merges characters with identical names 
 
DRIFT
    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         percentage of full swap to do in perturbation phase 
      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 
    Options set with "drift:[options];" or "drift=[options];" (first case 
    case changes settings only, second case runs). Using "drift:;" current 
    settings are displayed 
 
EDIT
    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 
 
ECHO
    =   echo each command 
    -   don't echo 
 
EXPORT
    export data in NEXUS format.  Copies everything after  
    the file name 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 
        [    save as dna 
        ]    save as standard 
 
FIT
    N   report total fit, for tree(s) N.  It is measured with a convex 
        increasing function, to be minimized 
    *N  report total fit (measured with a concave decreasing function, to  
        be maximized; the equivalent of what PAUP* and Pee-Wee report) 
 
FILLSANK
    =   complete polymorphic cells for Sankoff characters 
    -   don't (default) 
 
FORCE
    ;   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 
 
FREQDIFS
    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 
 
HELP
    ;     display list of commands 
    *     display options for all commands 
    xxx   display options for command xxx (equivalent to xxx ?) 
 
HOLD
    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 ) 
 
HYBRID
    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. 
    -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) 
 
IENUM
    Do implicit enumeration (=results guaranteed to be optimal; 
    feasible only for small data sets) 
 
INCLTAX
    [N   report which taxa are included in tree(s) N (default) 
    ]N   report which taxa are excluded from tree(s) N 
 
INFO
    +   report which character(s) are informative (default) 
    -     "      "        "       are uninformative 
 
LINTREES
    =    draw trees in Linux format (default) 
    -    don't 
    *    use command-recalling 
 
LOG
    xxx   open log file xxx (use "stdout" if redirecting output) 
    +xxx   open in append mode 
    /     close current log file 
 
KEEP
    N   keep no more than N trees, discard the rest 
 
LENGTH
    N   report total length, for tree(s) N 
 
LQUOTE
    =      set literal quotes on (see "quote") 
    -      set literal quotes off (see "quote") 
    [      within "quote" read &N as ASCII character N 
    ]      don't 
 
MAJORITY
    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 
 
MAP
    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 
 
MINMAX
    ;    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) 
 
MIXTREES
    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) 
 
MONO
    N    check whether tree(s) N satisfy constraints 
    -N   check whether tree(s) N violate constraints 
    *    same, but reporting group by group 
 
MRP
    Create matrix representing trees in memory 
 
MULT
    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) 
    Usage: "mult:options;" changes settings only; "mult=options;" runs 
    as well.  Entering "mult:;" current settings are reported. 
 
MXRAM
    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 
 
MXPROC
    N   allow up to N nested input files (default=10) 
 
NAKED
    =   show tree diagrams with out numbers (default) 
    -   with 
    ]   draw trees in narrow format 
    [   in default (=wide) format 
 
NELSEN
    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 
 
NSTATES
    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 short int 
        and 17 to 32 as long int.  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 
    min deletes uninformative states for non-additive characters, so that 
        each character has as few distinct states as possible 
    /   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. 
 
OUTGROUP
    N   make taxon N the outgroup (default = 0 ) 
 
PROCEDURE
    Redirect input 
      XXX;   take commands from file XXX 
      /;     close input file (include at end of 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) 
 
PAUSE
    =   enable pauses 
    -   don't (default) 
 
PFIJO
    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 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 
 
PIWE
    -    set implied weighting off (=default ) 
    =N;  set it on, with weighting constant N 
    :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 
 
PRUNCOM
    Find pruned combinable component consensus.  Syntax as in  
    "prunnelsen" --options + and ! not allowed. 
 
PRUNNELSEN
    =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. 
    [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 
           tree. 
 
PRUNTAX
    N/L   prunes taxon (taxa) L from tree(s) N.  If symbol 
          "!" is used as taxon list, it prunes all inactive 
          taxa. 
 
PTNT
    manage runs in parallel (parallel versions only) 
    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 
                             = ...new 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!). 
    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).  Current (or reduced) data are 
             automatically passed to each of the daughter processes (each 
             of which has a different random seed).  The '=' sign can be 
             preceded by one or several slashes ('/') indicating: 
                ram N      N: RAM to be used in each slave, in MBytes  
                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). 
                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. 
    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).  When jobs 
             are subsequently started, they 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 below, 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). 
 
QCOLLAPSE
    =   quick pre-collapsing during searches under mulpars (default) 
    -   no quick pre-collapsing 
 
QNELSEN
    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. 
 
QUOTE
    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
    quit the program 
 
RANDTREES
    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
    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 
                        trees 
       [no]dumpfuse     if fusing fails to produce a better tree, [don't] 
                        dump all the suboptimal trees 
    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 
 
RDIR
    xxx    set path for "run" files 
 
RECONS
    N/L;    most parsimonious reconstructions for character(s) L, tree(s) N 
 
REPORT
    =         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 ) 
 
REROOT
    N   re-root tree(s) N, using current outgroup 
 
RESAMPLE
    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 
       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. 
 
RESOLS
    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 
 
RIDDUP
    ;    deactivate duplicate taxa (according to current 
         character activities) and prune trees 
    *;   same, but leave at least two identical taxa 
         active/in tree 
    -    reactivate and reinsert duplicate inactive taxa 
 
RSEED
    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) 
    :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) 
 
RUN
    xxx arg1 arg2 ... argN;     parses file xxx, replacing %i by arg i 
 
SAVE
    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) 
 
SCREEN
    NxL   use screen of N lines and L rows 
 
SCORES
    N  calculate tree-scores (length or fit), for tree(s) N 
 
SECTSCH
    Do sectorial-search, starting from pre-existing trees. Options are: 
      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) 
      [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 
      [no]equals   accept equally good subtrees 
      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 
      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) 
      rounds N     for constraint-based selections, cycle N times over groups 
      global N     for smaller selections, do global TBR every N replacements 
      dglobal N    same, for larger selections (i.e. under drift and combined) 
      findscore N  stop drifting on tree if score N found 
      slack N      make N percent extra memory for searches (prevents 
                   memory errors during runs 
      [no]keepall  keep only the best trees [don't] 
      [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). 
      [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. 
      [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). 
    Options are set with "sectsch:options;" or "sectsch=options;" (using 
    ":" only settings are changed; "=" runs as well). With "sect:;"  
    current settings are displayed. 
 
SHORTREAD
    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 
 
SILENT
    Control output to xxx: 
       =xxx;    no output to xxx. 
       -xxx;    output to xxx. 
    "xxx" can be "all," "file," "console," or "buffer." 
 
SLAVEPROC
    reserved for use by parent process, in parallel TNT 
 
SMATRIX
    =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;") 
 
SORT
    N     sort tree(s) N, from best to worst 
 
SPRDIFF
    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 
             between the closest dichotomous resolution(s). 
    *J K NxS estimate SPR-swaps and show moves on tree diagrams 
 
SUBOPT
    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. 
 
SVTXT
    J K  save text-buffer lines J to L to output file (default = all) 
 
SYSTEM
    xxx<enter>  run xxx in system 
 
TABLES
    =   use optional table format 
    -   use default table format 
    /N  use N significant digits for floating point values (default=2) 
 
TAGSET
    N;  set tag to N (parallel versions only) 
 
TAXCODE
    -N;   de-activate taxon with number/name N (no N: show inactive taxa) 
    +N;   activate (no N: show active taxa) 
 
TAXLABELS
    N      report name of taxon N 
    xxx    report number of taxon named xxx 
 
TAXNAME
    =          when referring to terminal nodes, use names 
    -          don't (=default) 
    /XXX N     rename taxa N as XXX (if XXX is *, rename at random) 
 
TCHOOSE
    N   select tree N (use scopes, + and -) 
    /   select last memory tree, discard the rest 
 
TCOMP
    M N/L     show groups in tree M absent from N, excluding taxon (taxa) L 
    * N/L     same, keeping tree as last memory 
    *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). 
 
TEQUAL
    Show duplicate trees 
 
TFUSE
    /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   fuse set of trees N, and add resulting trees to existing set of trees. 
    Options (possibly preceded by "no" and defaults in parentheses):  
          equals       accept exchanges of equal score (don't) 
          beststart    use best tree to start (use it) 
          choose       choose only those exchanges that improve best score 
                       found so far (don't) 
          repeat       for every individual fuse, re-fuse trees until  
                       no exchanges improve it 
          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) 
          keepall      keep all trees found instead of best only (all) 
    Options are set with "tfuse:options;" or "tfuse=options;" (using 
    ":" only settings are changed; "=" runs as well). With "tfuse:;" 
    current settings are displayed. 
 
TGROUP
    Define group(s) of trees 
    Usage: 
         "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". 
 
THANKS
    show acknowledgments 
 
TIMEOUT
    set timeout for searches (dd: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. 
 
TNODES
    N   count nodes in tree(s) N 
 
TPLOT
    N    show tree(s) N. 
    *N   show tree(s) N in parenthetical notation. 
    /    show only last tree in memory 
 
TREAD
    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 
 
TSAVE
            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). 
 
TSHRINK
    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 
 
TSIZE
    N   count number of taxa included in tree(s) N 
 
TTAGS
    ;       show tree tag(s). 
    =       store tree tags for subsequent tree printing command(s) 
            (first tree printing command sets the target tree) 
    -       clear all existing tags 
    +N txt  write txt to node N of target tree 
    *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 
 
TXTSIZE
    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 
 
TZERT
    X Y  insert groups of tree X onto tree Y 
 
VIEW 
    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.  Screen size changed with >< or \/. 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. 
 
VVERSION
    show version 
 
WARN
    =   issue warnings 
    -   don't (default) 
 
WATCH
    =   time execution of commands 
    -   don't (deafult) 
 
XCOMP
    N    compare fit, character by character, between reference tree and 
         tree(s) N.  Must have defined a tree as reference, with "xcomp =X." 
 
XGROUP
    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) 
 
XINACT
    Deactivate all uninformative characters in matrix 
 
XMULT
    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 
                         sectsch:options) 
      [no]css            use constraint sectorial searches (settings with 
                         sectsch:options) 
      [no]xss            use exclusive sectorial searches (settings with 
                         sectsch:options) 
      [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]drift N        use N cycles of drifting (settings with drif:options) 
      [no]ratchet N      use N cycles of ratchet (settings with rat:options) 
      [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 
      [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 
      [no]verbose        produce verbose reports 
    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. 
 
XPERM
    N/L;   permute states within character(s) N, for taxa L 
    -;     undo last permutation 
 
XREAD
    Read data (Hennig86/NONA format; interleaved: each block preceded by "&") 
    Editing data: 
         =C T S  set states for taxon T, character C, to set S 
    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) 
    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. 
 
UNIQUE
        discard duplicate trees (without collapsing) 
    *   collapse first and then discard duplicates 
 
UNSHARED
    =   prune unshared taxa from trees when calculating consensus (default) 
    -   don't 
 
USMINMAX
    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) 
 
ZZZ
       Go to sleep!! (=quit) 
 
CONTINUE
    skip to next loop iteration 
 
COPYTREE
    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. 
 
CHKBREAK
    Check for user interrupt 
 
ELSE
    execute subsequent block of instructions when preceding IF not fulfilled 
 
END
    finish an IF block 
 
ENDLOOP
    terminate loop 
 
ENDSWAP
    terminate swapping 
 
ERRMSG
    xxx;   call error handler with error xxx 
 
GOTO
    fname N [args];   goto file "fname", and start parsing from 
                      point labeled N (with "label N;") 
    =fname;           define "fname" as default target 
    -;                undefine default target 
 
IF
    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. 
 
LABEL
    N;     mark point as label (see "goto"). 
 
LOOP
    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.  The 
    default maximum number of nested loops allowed is 15, but 
    can be changed with macro* to any number 
 
MACFLOAT
    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 
 
MACRO
    =        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 
 
MACREPORT
    =     inform results of comparisons/assignments during macros (=debugging) 
    -     don't (default) 
 
MACSEED
    N   set seed for random number generator for macros 
 
MAKETABLE
        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).  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." 
 
PRIVATE
    N;     keep N variables (besides named ones) as private 
 
PROGRESS
    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/;" 
 
RECURSE
    recursively call the input file being parsed (arguments 
    to "recurse" are passed to the input file) 
 
RESETSWAP
    save current rearrangement and re-start swapping  
    (valid only within tsprit or tbrit commands) 
 
RESETTIME
    re-set time for macros 
 
RETURN
    N;     set value of internal variable "exstatus" to N  
 
SAFE
    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
    Set value of user variables 
 
SETARRAY
    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) 
 
SETLOOP
    N;     reset loop to N 
 
SLAVEGET
    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. 
 
SLAVESET
    [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
    "sprit N (commands) stop" does SPR to tree N, executing "commands" 
    for each rearrangement (see also resetswap, endswap) 
 
TBRIT
    "tbrit N (commands) stop" does TBR to tree N, executing "commands" 
    for each rearrangement (see also resetswap, endswap, continue) 
 
VAR
    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).