Repository: Ecogenomics/GTDBTk (language: python)

Issue:
Updated to README and CLI help.

Previously annotated genomes
Am I missing something, how do I used GTDB with already annotated genomes that have faa and gbk files previously generated. 

GitHub issues are specifically for issues with the GTDB-Tk, please join us on the GTDB forum:

GTDB forum:
https://forum.gtdb.ecogenomic.org/

`iTOL` compatibility
Output trees from `gtdb-tk` are not compatible with `iTOL`, and `iTOL` is a very popular software for tree visualization. Standardization would help a lot. 


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/release-publish.yml b/.github/workflows/release-publish.yml
index 959b4255..6c9d79ac 100644
--- a/.github/workflows/release-publish.yml
+++ b/.github/workflows/release-publish.yml
@@ -40,6 +40,9 @@ jobs:
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Wait for PyPI to publish package
+        run: sleep 60s
+        shell: bash
       - name: Build and push
         uses: docker/build-push-action@v2
         with:
diff --git a/README.md b/README.md
index 8a41c7df..e31e612f 100644
--- a/README.md
+++ b/README.md
@@ -7,17 +7,27 @@
 [![Docker Image Version (latest by date)](https://img.shields.io/docker/v/ecogenomic/gtdbtk?sort=date&color=299bec&label=docker)](https://hub.docker.com/r/ecogenomic/gtdbtk)
 [![Docker Pulls](https://img.shields.io/docker/pulls/ecogenomic/gtdbtk?color=299bec&label=pulls)](https://hub.docker.com/r/ecogenomic/gtdbtk)
 
-<b>[GTDB-Tk v1.5.0](https://ecogenomics.github.io/GTDBTk/announcements.html) was released on April 23, 2021 along with new reference data for [GTDB R06-RS202](https://gtdb.ecogenomic.org/). Upgrading is recommended.</b>  
-<b> Please note v1.5.0+ is not compatible with GTDB R05-RS95. </b>
+<b>[GTDB-Tk v2.0.1](https://ecogenomics.github.io/GTDBTk/announcements.html) was released on April xx, 2022 along with new reference data for [GTDB R07-RS207](https://gtdb.ecogenomic.org/). Upgrading is recommended.</b>  
+<b> Please note v2.0.1+ is not compatible with GTDB R06-RS202. </b>
 
 GTDB-Tk is a software toolkit for assigning objective taxonomic classifications to bacterial and archaeal genomes based on the Genome Database Taxonomy [GTDB](https://gtdb.ecogenomic.org/). It is designed to work with recent advances that allow hundreds or thousands of metagenome-assembled genomes (MAGs) to be obtained directly from environmental samples. It can also be applied to isolate and single-cell genomes. The GTDB-Tk is open source and released under the [GNU General Public License (Version 3)](https://www.gnu.org/licenses/gpl-3.0.en.html).
 
 Notifications about GTDB-Tk releases will be available through the GTDB Twitter account (https://twitter.com/ace_gtdb).
 
-Please post questions and issues related to GTDB-Tk on the Issues section of the GitHub repository. Questions related to the [GTDB](https://gtdb.ecogenomic.org/) should be sent to the [GTDB team](https://gtdb.ecogenomic.org/about). 
+Please post questions and issues related to GTDB-Tk on the Issues section of the GitHub repository. Questions related to the [GTDB](https://gtdb.ecogenomic.org/) can be posted on the [GTDB Forum](https://forum.gtdb.ecogenomic.org/) or sent to the [GTDB team](https://gtdb.ecogenomic.org/about).
+
+## New Features
+
+GTDB-Tk v2.0.1 includes the following new features:
+- GTDB-TK now uses a **divide-and-conquer** approach where the bacterial reference tree is split into multiple order-level subtrees. This reduces the memory requirements of GTDB-Tk from **320 GB** of RAM when using the full GTDB R07-RS207 reference tree to approximately **35 GB**. A manuscript describing this approach is in preparation. If you wish to continue using the full GTDB reference tree use the `--full-tree` flag.
+- Archaeal classification now uses a refined set of 53 archaeal-specific marker genes based on the recent publication by [Dombrowski et al., 2020](https://www.nature.com/articles/s41467-020-17408-w). This set of archaeal marker genes is now used by GTDB for curating the archaeal taxonomy.
+- By default, all directories containing intermediate results are **now removed** by default at the end of the `classify_wf` and `de_novo_wf` pipelines. If you wish to retain these intermediates files use the `--keep-intermediates` flag.
+- All MSA files produced by the `align` step are now compressed with gzip.
+- The classification summary and failed genomes files are now the only files linked in the root directory of `classify_wf`.
+
 
 ## Documentation
-https://ecogenomics.github.io/GTDBTk/
+Documentation for GTDB-Tk can be found [here](https://ecogenomics.github.io/GTDBTk/).
 
 ## References
 
diff --git a/docs/requirements.txt b/docs/requirements.txt
index cb75a00e..d37b857b 100644
--- a/docs/requirements.txt
+++ b/docs/requirements.txt
@@ -1,7 +1,6 @@
-sphinx
-sphinx-argparse
-sphinx-rtd-theme
-recommonmark
-sphinx_rtd_theme
-sphinx-sitemap
-nbsphinx
+sphinx ~= 4.1.0
+sphinx-argparse ~= 0.2.0
+sphinx-rtd-theme ~= 0.5.0
+recommonmark ~= 0.7.0
+sphinx-sitemap ~= 2.2.0
+nbsphinx ~= 0.8.0
diff --git a/docs/src/announcements.rst b/docs/src/announcements.rst
index f3bb23e7..43e948ad 100644
--- a/docs/src/announcements.rst
+++ b/docs/src/announcements.rst
@@ -1,6 +1,27 @@
 Announcements
 =============
 
+
+GTDB R207 available
+------------------
+
+*April xx, 2022*
+
+* GTDB Release 202 is now available and will be used from version ``2.0.1`` and up.
+* This version of GTDB-Tk requires a new version of the GTDB-Tk reference package
+  `gtdbtk_r207_data.tar.gz <https://data.ace.uq.edu.au/public/gtdb/data/releases/release207/207.0/auxillary_files>`_.
+
+
+GTDB R202 available
+------------------
+
+*April 23, 2021*
+
+* GTDB Release 202 is now available and will be used from version ``1.5.0`` and up.
+* This version of GTDB-Tk requires a new version of the GTDB-Tk reference package
+  `gtdbtk_r202_data.tar.gz <https://data.ace.uq.edu.au/public/gtdb/data/releases/release202/202.0/auxillary_files>`_.
+
+
 GTDB R95 available
 ------------------
 
diff --git a/docs/src/changelog.rst b/docs/src/changelog.rst
index 9f35ce7a..cfcbc25e 100644
--- a/docs/src/changelog.rst
+++ b/docs/src/changelog.rst
@@ -52,7 +52,7 @@ Change log
 * Check if stdout is being piped to a file before adding colour.
 * (`#283 <https://github.com/Ecogenomics/GTDBTk/issues/283>`_) Significantly improved ``classify`` performance (noticeable when running trees > 1,000 taxa).
 * Automatically cap pplacer CPUs to 64 unless specifying ``--pplacer_cpus`` to prevent pplacer from hanging.
-* (`#262 <https://github.com/Ecogenomics/GTDBTk/issues/262>`_) Added ``--write_single_copy_genes`` to the ``identify`` command. Writes unaligned single-copy AR122/BAC120 marker genes to disk.
+* (`#262 <https://github.com/Ecogenomics/GTDBTk/issues/262>`_) Added ``--write_single_copy_genes`` to the ``identify`` command. Writes unaligned single-copy AR53/BAC120 marker genes to disk.
 * When running ``-version`` warn if GTDB-Tk is not running the most up-to-date version (disable via ``GTDBTK_VER_CHECK = False`` in ``config.py``). If GTDB-Tk encounters an error it will silently continue (3 second timeout).
 * (`#276 <https://github.com/Ecogenomics/GTDBTk/issues/276>`_) Renamed the column ``aa_percent`` to ``msa_percent`` in ``summary.tsv`` (produced by ``classify``).
 * (`#286 <https://github.com/Ecogenomics/GTDBTk/pull/286>`_) Fixed a file not found error when the reference data is a symbolic link (thanks `davidealbanese <https://github.com/davidealbanese>`_!).
diff --git a/docs/src/commands/align.rst b/docs/src/commands/align.rst
index 7120bef2..5bdcd957 100644
--- a/docs/src/commands/align.rst
+++ b/docs/src/commands/align.rst
@@ -3,7 +3,7 @@
 align
 =====
 
-Create a multiple sequence alignment based on the AR122/BAC120 marker set.
+Create a multiple sequence alignment based on the AR53/BAC120 marker set.
 
 
 Arguments
diff --git a/docs/src/commands/classify_wf.rst b/docs/src/commands/classify_wf.rst
index a30d9f0d..f68f17c1 100644
--- a/docs/src/commands/classify_wf.rst
+++ b/docs/src/commands/classify_wf.rst
@@ -8,7 +8,7 @@ Classify workflow
 
 For arguments and output files, see each of the individual steps:
 
-* :ref:`commands/infer`
+* :ref:`commands/identify`
 * :ref:`commands/align`
 * :ref:`commands/classify`
 
@@ -16,7 +16,7 @@ The classify workflow consists of three steps: ``identify``, ``align``, and ``cl
 
 The ``identify`` step calls genes using `Prodigal <http://compbio.ornl.gov/prodigal/>`_,
 and uses HMM models and the `HMMER <http://hmmer.org/>`_ package to identify the
-120 bacterial and 122 archaeal marker genes used for phylogenetic inference
+120 bacterial and 53 archaeal marker genes used for phylogenetic inference
 (`Parks et al., 2018 <https://www.ncbi.nlm.nih.gov/pubmed/30148503>`_). Multiple
 sequence alignments (MSA) are obtained by aligning marker genes to their respective HMM model.
 
diff --git a/docs/src/examples/classify_wf.ipynb b/docs/src/examples/classify_wf.ipynb
index 21211419..407cd2dc 100644
--- a/docs/src/examples/classify_wf.ipynb
+++ b/docs/src/examples/classify_wf.ipynb
@@ -133,7 +133,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "However, it is sometimes more useful to just read the summary files which detail markers identified from either the archaeal 122, or bacterial 120 marker set."
+    "However, it is sometimes more useful to just read the summary files which detail markers identified from either the archaeal 53, or bacterial 120 marker set."
    ]
   },
   {
@@ -152,7 +152,7 @@
     }
    ],
    "source": [
-    "cat /tmp/gtdbtk/identify/gtdbtk.ar122.markers_summary.tsv "
+    "cat /tmp/gtdbtk/identify/gtdbtk.ar53.markers_summary.tsv "
    ]
   },
   {
@@ -201,7 +201,7 @@
     "### Results\n",
     "It is important to pay attention to the output, if a genome had a low number of markers identified it will be excluded from the analysis at this step. A warning will appear if that is the case.\n",
     "\n",
-    "Depending on the domain, a prefixed file of either `ar122` or `bac120` will appear containing the MSA of the user genomes and the GTDB genomes, or just the user genomes (`gtdbtk.ar122.msa.fasta` and `gtdbtk.ar122.user_msa.fasta` respectively.)"
+    "Depending on the domain, a prefixed file of either `ar53` or `bac120` will appear containing the MSA of the user genomes and the GTDB genomes, or just the user genomes (`gtdbtk.ar53.msa.fasta` and `gtdbtk.ar53.user_msa.fasta` respectively.)"
    ]
   },
   {
@@ -213,9 +213,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001B[0m\u001B[38;5;27malign\u001B[0m                      \u001B[38;5;51mgtdbtk.ar122.user_msa.fasta\u001B[0m  \u001B[38;5;27midentify\u001B[0m\n",
-      "\u001B[38;5;51mgtdbtk.ar122.filtered.tsv\u001B[0m  gtdbtk.log\n",
-      "\u001B[38;5;51mgtdbtk.ar122.msa.fasta\u001B[0m     gtdbtk.warnings.log\n"
+      "\u001B[0m\u001B[38;5;27malign\u001B[0m                      \u001B[38;5;51mgtdbtk.ar53.user_msa.fasta\u001B[0m  \u001B[38;5;27midentify\u001B[0m\n",
+      "\u001B[38;5;51mgtdbtk.ar53.filtered.tsv\u001B[0m  gtdbtk.log\n",
+      "\u001B[38;5;51mgtdbtk.ar53.msa.fasta\u001B[0m     gtdbtk.warnings.log\n"
      ]
     }
    ],
@@ -264,7 +264,7 @@
    "metadata": {},
    "source": [
     "### Results\n",
-    "The two main files output (one again, depending on their domain) are the summary file, and the reference tree containing those genomes (`gtdbtk.ar122.summary.tsv`, and `gtdbtk.ar122.classify.tree` respectively). Classification of the genomes are present in the summary file."
+    "The two main files output (one again, depending on their domain) are the summary file, and the reference tree containing those genomes (`gtdbtk.ar53.summary.tsv`, and `gtdbtk.ar53.classify.tree` respectively). Classification of the genomes are present in the summary file."
    ]
   },
   {
@@ -276,8 +276,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "\u001B[0m\u001B[38;5;27mclassify\u001B[0m                    \u001B[38;5;51mgtdbtk.ar122.summary.tsv\u001B[0m  gtdbtk.warnings.log\n",
-      "\u001B[38;5;51mgtdbtk.ar122.classify.tree\u001B[0m  gtdbtk.log\n"
+      "\u001B[0m\u001B[38;5;27mclassify\u001B[0m                    \u001B[38;5;51mgtdbtk.ar53.summary.tsv\u001B[0m  gtdbtk.warnings.log\n",
+      "\u001B[38;5;51mgtdbtk.ar53.classify.tree\u001B[0m  gtdbtk.log\n"
      ]
     }
    ],
diff --git a/docs/src/files/markers_summary.tsv.rst b/docs/src/files/markers_summary.tsv.rst
index f5ef0c05..3ff92fb3 100644
--- a/docs/src/files/markers_summary.tsv.rst
+++ b/docs/src/files/markers_summary.tsv.rst
@@ -4,7 +4,7 @@ markers_summary.tsv
 ===================
 
 A summary of unique, duplicated, and missing markers within the 120 bacterial marker set, 
-or the 122 archaeal marker set for each submitted genome.
+or the 53 archaeal marker set for each submitted genome.
 
 For each genome:
 
diff --git a/docs/src/files/pplacer.domain.json.rst b/docs/src/files/pplacer.domain.json.rst
index 8934e626..cb31bd98 100644
--- a/docs/src/files/pplacer.domain.json.rst
+++ b/docs/src/files/pplacer.domain.json.rst
@@ -31,7 +31,7 @@ Example
         }
       ], "metadata":
       {"invocation":
-        "pplacer -m WAG -j 3 -c \/release89\/pplacer\/gtdb_r89_ar122.refpkg -o classify_output\/classify\/intermediate_results\/pplacer\/pplacer.ar122.json align_output\/align\/gtdbtk.ar122.user_msa.fasta"
+        "pplacer -m WAG -j 3 -c \/release89\/pplacer\/gtdb_r89_ar53.refpkg -o classify_output\/classify\/intermediate_results\/pplacer\/pplacer.ar53.json align_output\/align\/gtdbtk.ar53.user_msa.fasta"
       }, "version": 3, "fields":
       ["distal_length", "edge_num", "like_weight_ratio", "likelihood",
         "pendant_length"
diff --git a/docs/src/files/pplacer.domain.out.rst b/docs/src/files/pplacer.domain.out.rst
index d84cf8fa..ca50051e 100644
--- a/docs/src/files/pplacer.domain.out.rst
+++ b/docs/src/files/pplacer.domain.out.rst
@@ -16,7 +16,7 @@ Example
 
 .. code-block:: text
     
-    Running pplacer v1.1.alpha19-0-g807f6f3 analysis on align_output/align/gtdbtk.ar122.user_msa.fasta...
+    Running pplacer v1.1.alpha19-0-g807f6f3 analysis on align_output/align/gtdbtk.ar53.user_msa.fasta...
     Didn't find any reference sequences in given alignment file. Using supplied reference alignment.
     Pre-masking sequences... sequence length cut from 5124 to 5114.
     Determining figs... figs disabled.
diff --git a/docs/src/files/summary.tsv.rst b/docs/src/files/summary.tsv.rst
index 3f3014c8..0bff092c 100644
--- a/docs/src/files/summary.tsv.rst
+++ b/docs/src/files/summary.tsv.rst
@@ -4,7 +4,7 @@
 summary.tsv
 ===========
 
-Classifications provided by the GTDB-Tk are in the files \<prefix>.bac120.summary.tsv and \<prefix>.ar122.summary.tsv for bacterial and archaeal genomes, respectively. These are tab separated files with the following columns:
+Classifications provided by the GTDB-Tk are in the files \<prefix>.bac120.summary.tsv and \<prefix>.ar53.summary.tsv for bacterial and archaeal genomes, respectively. These are tab separated files with the following columns:
 
 * user_genome: Unique identifier of query genome taken from the FASTA file of the genome.
 * classification: GTDB taxonomy string inferred by the GTDB-Tk. An unassigned species (i.e., ``s__``) indicates that the query genome is either i) placed outside a named genus or ii) the ANI to the closest intra-genus reference genome with an AF >=0.65 is not within the species-specific ANI circumscription radius.
diff --git a/docs/src/installing/index.rst b/docs/src/installing/index.rst
index 4acf3063..4ee1ec43 100644
--- a/docs/src/installing/index.rst
+++ b/docs/src/installing/index.rst
@@ -34,12 +34,12 @@ Hardware requirements
      - Storage
      - Time
    * - Archaea
-     - ~13 GB
-     - ~27 GB
+     - ~34 GB
+     - ~65 GB
      - ~1 hour / 1,000 genomes @ 64 CPUs
    * - Bacteria
-     - ~215 GB
-     - ~27 GB
+     - ~320 GB ( 20GB for divide-and-conquer)
+     - ~65 GB
      - ~1 hour / 1,000 genomes @ 64 CPUs
 
 .. note::
diff --git a/gtdbtk/__init__.py b/gtdbtk/__init__.py
index ecc26b3f..1e144654 100644
--- a/gtdbtk/__init__.py
+++ b/gtdbtk/__init__.py
@@ -29,4 +29,4 @@
 __status__ = 'Production'
 __title__ = 'GTDB-Tk'
 __url__ = 'https://github.com/Ecogenomics/GTDBTk'
-__version__ = '1.7.0'
+__version__ = '2.0.1'
diff --git a/gtdbtk/__main__.py b/gtdbtk/__main__.py
index 43af9c06..35749469 100644
--- a/gtdbtk/__main__.py
+++ b/gtdbtk/__main__.py
@@ -48,14 +48,17 @@ def print_help():
     decorate -> Decorate tree with GTDB taxonomy
 
   Tools:
-    infer_ranks -> Establish taxonomic ranks of internal nodes using RED
-    ani_rep     -> Calculates ANI to GTDB representative genomes
-    trim_msa    -> Trim an untrimmed MSA file based on a mask
-    export_msa  -> Export the untrimmed archaeal or bacterial MSA file
+    infer_ranks     -> Establish taxonomic ranks of internal nodes using RED
+    ani_rep         -> Calculates ANI to GTDB representative genomes
+    trim_msa        -> Trim an untrimmed MSA file based on a mask
+    export_msa      -> Export the untrimmed archaeal or bacterial MSA file
+    remove_labels   -> Remove labels (bootstrap values, node labels) from an Newick tree
+    convert_to_itol -> Convert a GTDB-Tk Newick tree to an iTOL tree
+ 
 
   Testing:
     test          -> Validate the classify_wf pipeline with 3 archaeal genomes 
-    check_install -> Verify third party programs and GTDB reference package.
+    check_install -> Verify third party programs and GTDB reference package
 
   Use: gtdbtk <command> -h for command specific help
     ''' % __version__)
diff --git a/gtdbtk/biolib_lite/seq_io.py b/gtdbtk/biolib_lite/seq_io.py
index 35011db3..1212d60b 100644
--- a/gtdbtk/biolib_lite/seq_io.py
+++ b/gtdbtk/biolib_lite/seq_io.py
@@ -122,15 +122,19 @@ def read_fasta_seq(fasta_file, keep_annotation=False):
 
     try:
         open_file = open
+        mode = 'r'
         if fasta_file.endswith('.gz'):
             open_file = gzip.open
+            mode = 'rb'
 
         seq_id = None
         annotation = None
         seq = None
-        with open_file(fasta_file, 'r') as f:
+        with open_file(fasta_file, mode) as f:
 
             for line in f.readlines():
+                if isinstance(line, bytes):
+                    line = line.decode()
                 # skip blank lines
                 if not line.strip():
                     continue
diff --git a/gtdbtk/classify.py b/gtdbtk/classify.py
index 73d33113..d93eb98d 100644
--- a/gtdbtk/classify.py
+++ b/gtdbtk/classify.py
@@ -38,15 +38,19 @@
 from gtdbtk.exceptions import GenomeMarkerSetUnknown, GTDBTkExit
 from gtdbtk.external.fastani import FastANI
 from gtdbtk.external.pplacer import Pplacer
-from gtdbtk.io.classify_summary import ClassifySummaryFileAR122, ClassifySummaryFileBAC120, ClassifySummaryFileRow
-from gtdbtk.io.marker.copy_number import CopyNumberFileAR122, CopyNumberFileBAC120
-from gtdbtk.io.pplacer_classification import PplacerClassifyFileBAC120, PplacerClassifyFileAR122
+from gtdbtk.io.classify_summary import ClassifySummaryFileAR53, ClassifySummaryFileBAC120, ClassifySummaryFileRow
+from gtdbtk.io.marker.copy_number import CopyNumberFileAR53, CopyNumberFileBAC120
+from gtdbtk.io.pplacer_classification import PplacerClassifyFileBAC120, PplacerClassifyFileAR53, \
+    PplacerLowClassifyFileBAC120
 from gtdbtk.io.prodigal.tln_table_summary import TlnTableSummaryFile
-from gtdbtk.io.red_dict import REDDictFileAR122, REDDictFileBAC120
+from gtdbtk.io.red_dict import REDDictFileAR53, REDDictFileBAC120
+from gtdbtk.io.missing_genomes import DisappearingGenomesFileAR53, DisappearingGenomesFileBAC120
+from gtdbtk.io.tree_mapping import GenomeMappingFile, GenomeMappingFileRow
 from gtdbtk.markers import Markers
 from gtdbtk.relative_distance import RelativeDistance
+from gtdbtk.split import Split
 from gtdbtk.tools import add_ncbi_prefix, symlink_f, get_memory_gb, get_reference_ids, TreeTraversal, \
-    calculate_patristic_distance, tqdm_log
+    calculate_patristic_distance, tqdm_log, truncate_taxonomy, standardise_taxonomy
 
 sys.setrecursionlimit(15000)
 
@@ -83,13 +87,14 @@ def __init__(self, cpus=1, pplacer_cpus=None, af_threshold=None):
             self.pplacer_cpus = 64
 
         self.species_radius = self.parse_radius_file()
-
         self.reference_ids = get_reference_ids()
 
         # rank_of_interest determine the rank in the tree_mapping file for
         # lower classification
         self.rank_of_interest = "o__"
 
+
+
     def parse_radius_file(self):
         results = {}
         with open(Config.RADII_FILE) as f:
@@ -101,7 +106,7 @@ def parse_radius_file(self):
                 results[gid] = float(infos[2])
         return results
 
-    def parse_leaf_to_dir_path(self,genome_id):
+    def parse_leaf_to_dir_path(self, genome_id):
         """ Convert a genome id to a path.
          i.e GCA_123456789.0 would be converted to GCA/123/456/789/
 
@@ -113,8 +118,8 @@ def parse_leaf_to_dir_path(self,genome_id):
             path to the genome id path
         """
         try:
-            genome_path = '/'.join([genome_id[0:3],genome_id[4:7],
-                                    genome_id[7:10],genome_id[10:13]])
+            genome_path = '/'.join([genome_id[0:3], genome_id[4:7],
+                                    genome_id[7:10], genome_id[10:13]])
             return genome_path
         except IndexError:
             logger = logging.getLogger('timestamp')
@@ -128,7 +133,9 @@ def place_genomes(self,
                       prefix,
                       scratch_dir=None,
                       levelopt=None,
-                      tree_iter=None):
+                      tree_iter=None,
+                      number_low_trees=None,
+                      idx_tree=None):
         """Place genomes into reference tree using pplacer."""
 
         # Warn if the memory is insufficient
@@ -143,17 +150,17 @@ def place_genomes(self,
                 self.logger.warning(mem_warning.format(req_gb=Config.PPLACER_MIN_RAM_BAC,
                                                        domain='bacterial',
                                                        cur_gb=mem_total))
-            elif marker_set_id == 'ar122' and mem_total < Config.PPLACER_MIN_RAM_ARC:
+            elif marker_set_id == 'ar53' and mem_total < Config.PPLACER_MIN_RAM_ARC:
                 self.logger.warning(mem_warning.format(req_gb=Config.PPLACER_MIN_RAM_ARC,
                                                        domain='archaeal',
                                                        cur_gb=mem_total))
 
         # rename user MSA file for compatibility with pplacer
-        if not user_msa_file.endswith('.fasta'):
+        if not user_msa_file.endswith('.fasta') and not user_msa_file.endswith('.gz'):
             if marker_set_id == 'bac120':
                 t = PATH_BAC120_USER_MSA.format(prefix=prefix)
-            elif marker_set_id == 'ar122':
-                t = PATH_AR122_USER_MSA.format(prefix=prefix)
+            elif marker_set_id == 'ar53':
+                t = PATH_AR53_USER_MSA.format(prefix=prefix)
             else:
                 raise GenomeMarkerSetUnknown('There was an error determining the marker set.')
 
@@ -173,6 +180,7 @@ def place_genomes(self,
             make_sure_path_exists(scratch_dir)
 
         # get path to pplacer reference package
+        pplacer_ref_pkg = None
         if marker_set_id == 'bac120':
             if levelopt is None:
                 self.logger.log(Config.LOG_TASK,
@@ -181,28 +189,29 @@ def place_genomes(self,
                                 f'{self.pplacer_cpus} CPUs (be patient).')
                 pplacer_ref_pkg = os.path.join(Config.PPLACER_DIR,
                                                Config.PPLACER_BAC120_REF_PKG)
+
             elif levelopt == 'high':
                 self.logger.log(Config.LOG_TASK,
                                 f'Placing {num_genomes:,} bacterial genomes '
-                                f'into high reference tree with pplacer using '
+                                f'into backbone reference tree with pplacer using '
                                 f'{self.pplacer_cpus} CPUs (be patient).')
                 pplacer_ref_pkg = os.path.join(Config.HIGH_PPLACER_DIR,
                                                Config.HIGH_PPLACER_REF_PKG)
             elif levelopt == 'low':
                 self.logger.log(Config.LOG_TASK,
                                 f'Placing {num_genomes:,} bacterial genomes '
-                                f'into low reference tree {tree_iter} with '
+                                f'into order-level reference tree {tree_iter} ({idx_tree}/{number_low_trees}) with '
                                 f'pplacer using {self.pplacer_cpus} CPUs '
                                 f'(be patient).')
                 pplacer_ref_pkg = os.path.join(Config.LOW_PPLACER_DIR,
                                                Config.LOW_PPLACER_REF_PKG.format(iter=tree_iter))
-        elif marker_set_id == 'ar122':
+        elif marker_set_id == 'ar53':
             self.logger.log(Config.LOG_TASK,
                             f'Placing {num_genomes:,} archaeal genomes into '
                             f'reference tree with pplacer using '
                             f'{self.pplacer_cpus} CPUs (be patient).')
             pplacer_ref_pkg = os.path.join(Config.PPLACER_DIR,
-                                           Config.PPLACER_AR122_REF_PKG)
+                                           Config.PPLACER_AR53_REF_PKG)
         else:
             raise GenomeMarkerSetUnknown(f'Unknown marker set: {marker_set_id}')
 
@@ -212,6 +221,7 @@ def place_genomes(self,
             os.makedirs(pplacer_out_dir)
 
         # run pplacer
+        pplacer_json_out, pplacer_out = None, None
         if marker_set_id == 'bac120':
             if levelopt is None:
                 pplacer_out = os.path.join(out_dir, PATH_BAC120_PPLACER_OUT)
@@ -227,9 +237,9 @@ def place_genomes(self,
                     out_dir, PATH_LOW_BAC120_PPLACER_OUT.format(iter=tree_iter))
                 pplacer_json_out = os.path.join(
                     out_dir, PATH_LOW_BAC120_PPLACER_JSON.format(iter=tree_iter))
-        elif marker_set_id == 'ar122':
-            pplacer_out = os.path.join(out_dir, PATH_AR122_PPLACER_OUT)
-            pplacer_json_out = os.path.join(out_dir, PATH_AR122_PPLACER_JSON)
+        elif marker_set_id == 'ar53':
+            pplacer_out = os.path.join(out_dir, PATH_AR53_PPLACER_OUT)
+            pplacer_json_out = os.path.join(out_dir, PATH_AR53_PPLACER_JSON)
         else:
             self.logger.error('There was an error determining the marker set.')
             raise GenomeMarkerSetUnknown
@@ -237,10 +247,14 @@ def place_genomes(self,
         pplacer = Pplacer()
         if levelopt is None or levelopt == 'high':
             self.logger.info(f'pplacer version: {pplacer.version}')
-        pplacer.run(self.pplacer_cpus, 'wag', pplacer_ref_pkg, pplacer_json_out,
-                    user_msa_file, pplacer_out, pplacer_mmap_file)
+        # #DEBUG line
+        run_pplacer = True
+        if run_pplacer:
+            pplacer.run(self.pplacer_cpus, 'wag', pplacer_ref_pkg, pplacer_json_out,
+                        user_msa_file, pplacer_out, pplacer_mmap_file)
 
         # extract tree
+        tree_file = None
         if marker_set_id == 'bac120':
             if levelopt is None:
                 tree_file = os.path.join(
@@ -251,9 +265,9 @@ def place_genomes(self,
             elif levelopt == 'low':
                 tree_file = os.path.join(
                     out_dir, PATH_LOW_BAC120_TREE_FILE.format(prefix=prefix, iter=tree_iter))
-        elif marker_set_id == 'ar122':
+        elif marker_set_id == 'ar53':
             tree_file = os.path.join(
-                out_dir, PATH_AR122_TREE_FILE.format(prefix=prefix))
+                out_dir, PATH_AR53_TREE_FILE.format(prefix=prefix))
         else:
             self.logger.error('There was an error determining the marker set.')
             raise GenomeMarkerSetUnknown
@@ -261,64 +275,44 @@ def place_genomes(self,
         pplacer.tog(pplacer_json_out, tree_file)
 
         # Symlink to the tree summary file
-        if marker_set_id == 'bac120':
-            symlink_f(PATH_BAC120_TREE_FILE.format(prefix=prefix),
-                      os.path.join(out_dir, os.path.basename(PATH_BAC120_TREE_FILE.format(prefix=prefix))))
-        elif marker_set_id == 'ar122':
-            symlink_f(PATH_AR122_TREE_FILE.format(prefix=prefix),
-                      os.path.join(out_dir, os.path.basename(PATH_AR122_TREE_FILE.format(prefix=prefix))))
-        else:
-            self.logger.error('There was an error determining the marker set.')
-            raise GenomeMarkerSetUnknown
+        # if marker_set_id == 'bac120' and levelopt is None:
+        #     symlink_f(PATH_BAC120_TREE_FILE.format(prefix=prefix),
+        #               os.path.join(out_dir, os.path.basename(PATH_BAC120_TREE_FILE.format(prefix=prefix))))
+        # elif levelopt == 'high':
+        #     symlink_f(PATH_HIGH_BAC120_TREE_FILE.format(prefix=prefix),
+        #               os.path.join(out_dir, os.path.basename(PATH_HIGH_BAC120_TREE_FILE.format(prefix=prefix))))
+        # elif levelopt == 'low':
+        #     symlink_f(PATH_LOW_BAC120_TREE_FILE.format(prefix=prefix, iter=tree_iter),
+        #               os.path.join(out_dir,
+        #                            os.path.basename(PATH_LOW_BAC120_TREE_FILE.format(prefix=prefix, iter=tree_iter))))
+        # elif marker_set_id == 'ar53':
+        #     symlink_f(PATH_AR53_TREE_FILE.format(prefix=prefix),
+        #               os.path.join(out_dir, os.path.basename(PATH_AR53_TREE_FILE.format(prefix=prefix))))
+        # else:
+        #     self.logger.error('There was an error determining the marker set.')
+        #     raise GenomeMarkerSetUnknown
 
         # Symlink to the tree summary file
-        if marker_set_id == 'bac120':
-            if levelopt is None:
-                symlink_f(PATH_BAC120_TREE_FILE.format(prefix=prefix),
-                          os.path.join(out_dir, os.path.basename(PATH_BAC120_TREE_FILE.format(prefix=prefix))))
-            elif levelopt == 'high':
-                symlink_f(PATH_HIGH_BAC120_TREE_FILE.format(prefix=prefix),
-                          os.path.join(out_dir, os.path.basename(PATH_HIGH_BAC120_TREE_FILE.format(prefix=prefix))))
-            elif levelopt == 'low':
-                symlink_f(PATH_LOW_BAC120_TREE_FILE.format(iter=tree_iter, prefix=prefix),
-                          os.path.join(out_dir, os.path.basename(PATH_LOW_BAC120_TREE_FILE.format(iter=tree_iter, prefix=prefix))))
-        elif marker_set_id == 'ar122':
-            symlink_f(PATH_AR122_TREE_FILE.format(prefix=prefix),
-                      os.path.join(out_dir, os.path.basename(PATH_AR122_TREE_FILE.format(prefix=prefix))))
-        else:
-            self.logger.error('There was an error determining the marker set.')
-            raise GenomeMarkerSetUnknown
+        # if marker_set_id == 'bac120':
+        #     if levelopt is None:
+        #         symlink_f(PATH_BAC120_TREE_FILE.format(prefix=prefix),
+        #                   os.path.join(out_dir, os.path.basename(PATH_BAC120_TREE_FILE.format(prefix=prefix))))
+        #     elif levelopt == 'high':
+        #         symlink_f(PATH_HIGH_BAC120_TREE_FILE.format(prefix=prefix),
+        #                   os.path.join(out_dir, os.path.basename(PATH_HIGH_BAC120_TREE_FILE.format(prefix=prefix))))
+        #     elif levelopt == 'low':
+        #         symlink_f(PATH_LOW_BAC120_TREE_FILE.format(iter=tree_iter, prefix=prefix),
+        #                   os.path.join(out_dir, os.path.basename(
+        #                       PATH_LOW_BAC120_TREE_FILE.format(iter=tree_iter, prefix=prefix))))
+        # elif marker_set_id == 'ar53':
+        #     symlink_f(PATH_AR53_TREE_FILE.format(prefix=prefix),
+        #               os.path.join(out_dir, os.path.basename(PATH_AR53_TREE_FILE.format(prefix=prefix))))
+        # else:
+        #     self.logger.error('There was an error determining the marker set.')
+        #     raise GenomeMarkerSetUnknown
 
         return tree_file
 
-    def standardise_taxonomy(self, taxstring, marker_set=None):
-        """Create a 7 rank taxonomy string from an incomplete taxonomy string
-
-        Parameters
-        ----------
-        taxstring : str
-            incomplete taxonomy string
-        marker_set : str
-            The marker set to use.
-
-        Returns
-        -------
-        string
-            7 rank taxonomy string.
-        """
-        # return taxstring
-        taxlist = taxstring.split(";")
-        while '' in taxlist:
-            taxlist.remove('')
-        if marker_set == 'bac120':
-            taxlist.insert(0, 'd__Bacteria')
-        if marker_set == 'ar122':
-            taxlist.insert(0, 'd__Archaea')
-        taxlist.extend(self.order_rank[len(taxlist):])
-        new_taxstring = ";".join(taxlist)
-        return new_taxstring
-
-
     def _parse_red_dict(self, red_dist_dict):
         results = {}
         for k, v in red_dist_dict.items():
@@ -355,29 +349,44 @@ def run(self,
             scratch_dir=None,
             recalculate_red=None,
             debugopt=False,
-            splittreeopt=False):
+            fulltreeopt=False):
         """Classify genomes based on position in reference tree."""
 
         _bac_gids, _ar_gids, bac_ar_diff = Markers().genome_domain(align_dir, prefix)
+        disappearing_genomes = []
 
-        for marker_set_id in ('ar122', 'bac120'):
+        for marker_set_id in ('ar53', 'bac120'):
 
-            if marker_set_id == 'ar122':
-                marker_summary_fh = CopyNumberFileAR122(align_dir, prefix)
+            if marker_set_id == 'ar53':
+                marker_summary_fh = CopyNumberFileAR53(align_dir, prefix)
                 marker_summary_fh.read()
-                user_msa_file = os.path.join(align_dir,
-                                             PATH_AR122_USER_MSA.format(prefix=prefix))
-                summary_file = ClassifySummaryFileAR122(out_dir, prefix)
-                red_dict_file = REDDictFileAR122(out_dir, prefix)
-                pplacer_classify_file = PplacerClassifyFileAR122(out_dir, prefix)
+                if os.path.isfile(os.path.join(align_dir,
+                                             PATH_AR53_USER_MSA.format(prefix=prefix))):
+                    user_msa_file = os.path.join(align_dir,
+                                                 PATH_AR53_USER_MSA.format(prefix=prefix))
+                else:
+                    user_msa_file = os.path.join(align_dir,
+                                                 PATH_AR53_USER_MSA.format(prefix=prefix)+'.gz')
+                summary_file = ClassifySummaryFileAR53(out_dir, prefix)
+                red_dict_file = REDDictFileAR53(out_dir, prefix)
+                disappearing_genomes_file = DisappearingGenomesFileAR53(out_dir, prefix)
+                pplacer_classify_file = PplacerClassifyFileAR53(out_dir, prefix)
             elif marker_set_id == 'bac120':
                 marker_summary_fh = CopyNumberFileBAC120(align_dir, prefix)
                 marker_summary_fh.read()
-                user_msa_file = os.path.join(align_dir,
-                                             PATH_BAC120_USER_MSA.format(prefix=prefix))
+                if os.path.isfile(os.path.join(align_dir,
+                                             PATH_BAC120_USER_MSA.format(prefix=prefix))):
+                    user_msa_file = os.path.join(align_dir,
+                                                 PATH_BAC120_USER_MSA.format(prefix=prefix))
+                else:
+                    user_msa_file = os.path.join(align_dir,
+                                                 PATH_BAC120_USER_MSA.format(prefix=prefix)+'.gz')
                 summary_file = ClassifySummaryFileBAC120(out_dir, prefix)
                 red_dict_file = REDDictFileBAC120(out_dir, prefix)
+                disappearing_genomes_file = DisappearingGenomesFileBAC120(out_dir, prefix)
                 pplacer_classify_file = PplacerClassifyFileBAC120(out_dir, prefix)
+                if not fulltreeopt:
+                    tree_mapping_file = GenomeMappingFile(out_dir, prefix)
             else:
                 raise GenomeMarkerSetUnknown('There was an error determining the marker set.')
 
@@ -397,11 +406,12 @@ def run(self,
 
             msa_dict = read_fasta(user_msa_file)
 
-            if splittreeopt is True:
+            if not fulltreeopt and marker_set_id == 'bac120':
+                splitter = Split(self.order_rank, self.gtdb_taxonomy, self.reference_ids)
                 # run pplacer to place bins in reference genome tree
-                num_genomes = sum([1 for _seq_id, _seq in read_seq(user_msa_file)])
-                debugfile, conflict_file = self._generate_summary_file(
-                    marker_set_id, prefix, out_dir, debugopt, splittreeopt)
+                genomes_to_process=[seq_id for seq_id, _seq in read_seq(user_msa_file)]
+                debug_file, conflict_file = self._generate_summary_file(
+                    marker_set_id, prefix, out_dir, debugopt, fulltreeopt)
 
                 high_classify_tree = self.place_genomes(user_msa_file,
                                                         marker_set_id,
@@ -412,33 +422,64 @@ def run(self,
                 tree = self._assign_mrca_red(
                     high_classify_tree, marker_set_id, 'high')
 
-                high_classification = self._get_high_pplacer_taxonomy(
+                high_classification = splitter.get_high_pplacer_taxonomy(
                     out_dir, marker_set_id, prefix, user_msa_file, tree)
 
+                disappearing_genomes = [seq_id for seq_id in genomes_to_process if seq_id not in high_classification]
+                if disappearing_genomes:
+                    for disappearing_genome in disappearing_genomes:
+                        disappearing_genomes_file.add_genome(disappearing_genome,'Backbone')
+
                 tree_mapping_dict = {}
+                tree_mapping_dict_reverse = {}
                 with open(Config.LOW_TREE_MAPPING_FILE) as ltmf:
                     for line in ltmf:
                         k, v = line.strip().split()
                         tree_mapping_dict[k] = v
+                        tree_mapping_dict_reverse.setdefault(v, []).append(k)
 
-                sorted_high_taxonomy, len_sorted_genomes = self._map_high_taxonomy(
+                splitter = Split(self.order_rank,self.gtdb_taxonomy,self.reference_ids)
+                sorted_high_taxonomy, len_sorted_genomes = splitter.map_high_taxonomy(
                     high_classification, tree_mapping_dict, summary_file)
-                self.logger.info(f"{len_sorted_genomes} out of {num_genomes} have an order assignments. Those genomes will be reclassified.")
+                self.logger.info(f"{len_sorted_genomes} out of {len(genomes_to_process)} have an order assignments. Those genomes "
+                                 f"will be reclassified.")
 
-                for tree_iter in sorted(sorted_high_taxonomy, key=lambda z: len(sorted_high_taxonomy[z]), reverse=True):
+                for idx, tree_iter in enumerate(
+                        sorted(sorted_high_taxonomy, key=lambda z: len(sorted_high_taxonomy[z]), reverse=True)):
                     listg = sorted_high_taxonomy.get(tree_iter)
                     low_classify_tree, submsa_file_path = self._place_in_low_tree(
-                        tree_iter, listg, msa_dict, marker_set_id, prefix, scratch_dir, out_dir)
+                        tree_iter, len(sorted_high_taxonomy), idx + 1, listg, msa_dict, marker_set_id, prefix,
+                        scratch_dir, out_dir)
+                    genomes_to_process = [seq_id for seq_id, _seq in read_seq(submsa_file_path)]
                     mrca_lowtree = self._assign_mrca_red(
                         low_classify_tree, marker_set_id, 'low', tree_iter)
+                    pplacer_classify_file = PplacerLowClassifyFileBAC120(out_dir, prefix,tree_iter)
                     pplacer_taxonomy_dict = self._get_pplacer_taxonomy(pplacer_classify_file,
-                        marker_set_id, user_msa_file, mrca_lowtree)
+                                                                       marker_set_id, user_msa_file, mrca_lowtree)
+                    disappearing_genomes = [seq_id for seq_id in genomes_to_process if
+                                            seq_id not in pplacer_taxonomy_dict]
+                    if disappearing_genomes:
+                        self.logger.warning(f"{len(disappearing_genomes)} out of {len(genomes_to_process)} have not been"
+                                            f" properly placed by pplacer. This is a known issue with pplacer but we do "
+                                            f"not have a solution currently. Those missing genomes are written to "
+                                            f"the {disappearing_genomes_file.file_name} file. We recommend rerunning "
+                                            f"those genomes through GTDB-Tk to 'fix' the problem.")
+                        for disappearing_genome in disappearing_genomes:
+                            disappearing_genomes_file.add_genome(disappearing_genome, tree_iter)
+
+                    self._parse_tree(mrca_lowtree, genomes, msa_dict,
+                                     percent_multihit_dict, tln_table_summary_file.genomes,
+                                     bac_ar_diff, submsa_file_path, red_dict_file.data,
+                                     summary_file, conflict_file, pplacer_taxonomy_dict,
+                                     high_classification, debug_file, debugopt,
+                                     tree_mapping_file, tree_iter, tree_mapping_dict_reverse)
+
+                # Symlink to the summary file from the root
+                symlink_f(PATH_BAC120_SUMMARY_OUT.format(prefix=prefix),
+                          os.path.join(out_dir, os.path.basename(PATH_BAC120_SUMMARY_OUT.format(prefix=prefix))))
 
-                    self._parse_tree(mrca_lowtree, genomes, msa_dict, percent_multihit_dict, tln_table_summary_file.genomes,
-                                     bac_ar_diff, submsa_file_path, red_dict_file.data, summary_file, conflict_file, pplacer_taxonomy_dict,
-                                     high_classification, debugfile, debugopt)
                 if debugopt:
-                    debugfile.close()
+                    debug_file.close()
 
             else:
                 classify_tree = self.place_genomes(user_msa_file,
@@ -447,9 +488,11 @@ def run(self,
                                                    prefix,
                                                    scratch_dir)
 
+                genomes_to_process = [seq_id for seq_id, _seq in read_seq(user_msa_file)]
+
                 # get taxonomic classification of each user genome
-                debugfile, conflict_file = self._generate_summary_file(
-                    marker_set_id, prefix, out_dir, debugopt, splittreeopt)
+                debug_file, conflict_file = self._generate_summary_file(
+                    marker_set_id, prefix, out_dir, debugopt, fulltreeopt)
 
                 if recalculate_red:
                     tree_to_process = self._calculate_red_distances(
@@ -463,45 +506,61 @@ def run(self,
                                                                    user_msa_file,
                                                                    tree_to_process)
 
+                disappearing_genomes = [seq_id for seq_id in genomes_to_process if seq_id not in pplacer_taxonomy_dict]
+
+
                 self._parse_tree(tree_to_process, genomes, msa_dict, percent_multihit_dict,
                                  tln_table_summary_file.genomes,
                                  bac_ar_diff, user_msa_file, red_dict_file.data, summary_file, conflict_file,
                                  pplacer_taxonomy_dict, None,
-                                 debugfile, debugopt)
+                                 debug_file, debugopt, None, None, None)
 
                 # Symlink to the summary file from the root
                 if marker_set_id == 'bac120':
                     symlink_f(PATH_BAC120_SUMMARY_OUT.format(prefix=prefix),
                               os.path.join(out_dir, os.path.basename(PATH_BAC120_SUMMARY_OUT.format(prefix=prefix))))
-                elif marker_set_id == 'ar122':
-                    symlink_f(PATH_AR122_SUMMARY_OUT.format(prefix=prefix),
-                              os.path.join(out_dir, os.path.basename(PATH_AR122_SUMMARY_OUT.format(prefix=prefix))))
+                elif marker_set_id == 'ar53':
+                    symlink_f(PATH_AR53_SUMMARY_OUT.format(prefix=prefix),
+                              os.path.join(out_dir, os.path.basename(PATH_AR53_SUMMARY_OUT.format(prefix=prefix))))
                 else:
                     raise GenomeMarkerSetUnknown('There was an error determining the marker set.')
 
+                if disappearing_genomes:
+                    for disappearing_genome in disappearing_genomes:
+                        disappearing_genomes_file.add_genome(disappearing_genome,'N/A')
+
+
                 if debugopt:
-                    debugfile.close()
+                    debug_file.close()
+
+
+
+            if not fulltreeopt and marker_set_id == 'bac120':
+                tree_mapping_file.write()
 
             # Write the summary file to disk.
+            if disappearing_genomes_file.data:
+                disappearing_genomes_file.write()
             summary_file.write()
 
-    def _generate_summary_file(self, marker_set_id, prefix, out_dir, debugopt=None, splittreeopt=None):
-        debugfile = None
+    def _generate_summary_file(self, marker_set_id, prefix, out_dir, debugopt=None, fulltreeopt=None):
+        debug_file = None
         conflict_summary = None
 
         if debugopt:
-            debugfile = open(os.path.join(
+            debug_file = open(os.path.join(
                 out_dir, prefix + '.{}.debug_file.tsv'.format(marker_set_id)), 'w')
-            debugfile.write(
+            debug_file.write(
                 "User genome\tRed value\tHigher rank\tHigher value\tLower rank\tLower value\tcase\tclosest_rank\ttool\n")
-        if splittreeopt:
+        if not fulltreeopt:
             conflict_summary = open(os.path.join(
                 out_dir, PATH_BAC120_CONFLICT.format(prefix=prefix)), 'w')
             conflict_summary.write(
-                "User genome\tHigh classification\tLow Classification\n")
-        return debugfile, conflict_summary
+                "User genome\tHigh classification\tLow Classification\tType Classification\n")
+        return debug_file, conflict_summary
 
-    def _place_in_low_tree(self, tree_iter, listg, msa_dict, marker_set_id, prefix, scratch_dir, out_dir):
+    def _place_in_low_tree(self, tree_iter, number_low_trees, idx_tree, listg, msa_dict, marker_set_id, prefix,
+                           scratch_dir, out_dir):
         make_sure_path_exists(os.path.join(
             out_dir, DIR_LOW_PPLACER.format(iter=tree_iter)))
         submsa_file_path = os.path.join(
@@ -512,12 +571,13 @@ def _place_in_low_tree(self, tree_iter, listg, msa_dict, marker_set_id, prefix,
         for gid in listg:
             submsa_file.write('>{}\n{}\n'.format(gid, msa_dict.get(gid)))
         submsa_file.close()
-        low_classify_tree = self.place_genomes(PATH_LOW_BAC120_SUBMSA.format(iter=tree_iter),
+        low_classify_tree = self.place_genomes(submsa_file_path,
                                                marker_set_id,
                                                out_dir,
                                                prefix,
                                                scratch_dir,
-                                               'low', tree_iter)
+                                               'low', tree_iter,
+                                               number_low_trees, idx_tree)
         return low_classify_tree, submsa_file_path
 
     @staticmethod
@@ -595,12 +655,12 @@ def _get_fastani_verification(tree, reference_ids, tt):
                     out[leaf_node] = {"potential_g": [(leaf_ref_genome, 0.0)],
                                       "pplacer_g": leaf_ref_genome}
 
-        return out
+        return out, qry_nodes
 
     def _classify_red_topology(self, tree, msa_dict, percent_multihit_dict, trans_table_dict, bac_ar_diff,
                                user_msa_file, red_dict, summary_file, conflict_file, pplacer_taxonomy_dict,
-                               high_classification, debugfile, debugopt, classified_user_genomes,
-                               unclassified_user_genomes, tt):
+                               high_classification, debug_file, debugopt, classified_user_genomes,
+                               unclassified_user_genomes, tt, order_in_spe_tree):
         user_genome_ids = set(read_fasta(user_msa_file).keys())
         user_genome_ids = user_genome_ids.difference(set(classified_user_genomes))
         for leaf in tree.leaf_node_iter(filter_fn=lambda x: x.taxon.label in user_genome_ids):
@@ -682,6 +742,7 @@ def _classify_red_topology(self, tree, msa_dict, percent_multihit_dict, trans_ta
                         list_subrank.append(self.gtdb_taxonomy.get(leaf_subrank)
                                             [self.order_rank.index(parent_rank) + 1])
                     if len(set(list_subrank)) == 1:
+                        print(leaf.taxon.label)
                         print(list_leaves)
                         print(list_subrank)
                         raise GTDBTkExit('There should be only one leaf.')
@@ -753,50 +814,113 @@ def _classify_red_topology(self, tree, msa_dict, percent_multihit_dict, trans_ta
             list_subnode = [subnd.taxon.label.replace("'", '')
                             for subnd in tt.get_leaf_nodes(cur_node)]
             red_taxonomy = self._get_redtax(list_subnode, closest_rank)
+            notes = []
 
-            del debug_info[0]
+            standardised_red_tax = standardise_taxonomy(';'.join(red_taxonomy))
 
-            summary_row = ClassifySummaryFileRow()
-            if leaf.taxon.label in unclassified_user_genomes:
-                summary_row = unclassified_user_genomes.get(leaf.taxon.label)
-                if summary_row.note == '':
-                    summary_row.note = None
-            summary_row.gid = leaf.taxon.label
-            summary_row.classification = self.standardise_taxonomy(red_taxonomy)
-            summary_row.pplacer_tax = pplacer_taxonomy_dict.get(leaf.taxon.label)
-            if summary_row.classification_method is None:
-                summary_row.classification_method = detection
-            summary_row.msa_percent = self.aa_percent_msa(msa_dict.get(summary_row.gid))
-            summary_row.tln_table = trans_table_dict.get(summary_row.gid)
-            summary_row.red_value = current_rel_list
+            if order_in_spe_tree and 'o__;' in standardised_red_tax:
+                v = high_classification.get(leaf.taxon.label)
+                tk_tax_red_without_order = truncate_taxonomy(v.get('tk_tax_red'), 'o__')
+                summary_row = ClassifySummaryFileRow()
+                summary_row.gid = leaf.taxon.label
+                summary_row.classification = tk_tax_red_without_order
+                summary_row.pplacer_tax = v.get('pplacer_tax')
+                summary_row.red_value = v.get('rel_dist')
+                notes.append(
+                    'Genome not classified with order in species tree, reverse to backbone tree classification.')
+
+                #### Test 1.2
+            elif order_in_spe_tree and self.check_common_rank_btwn_tax(standardised_red_tax,high_classification.get(leaf.taxon.label),'f__'):
+                summary_row = self.generate_summary_row_reverse_to_backbone(standardised_red_tax, leaf, high_classification)
+                notes.append('Genome has conflicting families between trees, reverse to backbone tree classification.')
+            elif order_in_spe_tree and self.check_common_rank_btwn_tax(standardised_red_tax,high_classification.get(leaf.taxon.label),'o__'):
+                summary_row = self.generate_summary_row_reverse_to_backbone(standardised_red_tax, leaf, high_classification)
+                notes.append('Genome has conflicting orders between trees, reverse to backbone tree classification.')
+            elif order_in_spe_tree and self.check_common_rank_btwn_tax(standardised_red_tax,high_classification.get(leaf.taxon.label),'c__'):
+                summary_row = self.generate_summary_row_reverse_to_backbone(standardised_red_tax,leaf,high_classification)
+                notes.append('Genome has conflicting classes between trees, reverse to backbone tree classification.')
+
+            elif order_in_spe_tree and red_taxonomy[
+                self.order_rank.index(self.rank_of_interest)] not in order_in_spe_tree:
+                v = high_classification.get(leaf.taxon.label)
+                tk_tax_red_without_order = truncate_taxonomy(v.get('tk_tax_red'), 'o__')
+                summary_row = ClassifySummaryFileRow()
+                summary_row.gid = leaf.taxon.label
+                summary_row.classification = tk_tax_red_without_order
+                summary_row.pplacer_tax = v.get('pplacer_tax')
+                summary_row.red_value = v.get('rel_dist')
+                notes.append('Genome placed in dummy order in species tree, reverse to backbone tree classification.')
+            else:
+                del debug_info[0]
+                summary_row = ClassifySummaryFileRow()
+                if leaf.taxon.label in unclassified_user_genomes:
+                    summary_row = unclassified_user_genomes.get(leaf.taxon.label)
+                    if summary_row.note == '':
+                        summary_row.note = None
+                summary_row.gid = leaf.taxon.label
+                summary_row.classification = standardise_taxonomy(';'.join(red_taxonomy))
+                summary_row.pplacer_tax = pplacer_taxonomy_dict.get(leaf.taxon.label)
+                if summary_row.classification_method is None:
+                    summary_row.classification_method = detection
+                summary_row.msa_percent = self.aa_percent_msa(msa_dict.get(summary_row.gid))
+                summary_row.tln_table = trans_table_dict.get(summary_row.gid)
+                summary_row.red_value = current_rel_list
 
-            notes = []
             if summary_row.gid in percent_multihit_dict:
                 notes.append('Genome has more than {}% of markers with multiple hits'.format(
                     percent_multihit_dict.get(summary_row.gid)))
             if summary_row.gid in bac_ar_diff:
                 notes.append('Genome domain questionable ( {}% Bacterial, {}% Archaeal)'.format(
                     bac_ar_diff.get(summary_row.gid).get('bac120'),
-                    bac_ar_diff.get(summary_row.gid).get('ar122')))
+                    bac_ar_diff.get(summary_row.gid).get('ar53')))
 
             if len(notes) > 0:
                 summary_row.warnings = ';'.join(notes)
             summary_file.add_row(summary_row)
 
             if debugopt:
-                debugfile.write('{0}\t{1}\t{2}\t{3}\n'.format(
+                debug_file.write('{0}\t{1}\t{2}\t{3}\n'.format(
                     leaf.taxon.label, current_rel_list, '\t'.join(str(x) for x in debug_info), detection))
             if high_classification and leaf.taxon.label in high_classification:
-                fullrank = [x for x in high_classification.get(leaf.taxon.label).get('tk_tax').split(
+                fullrank_terminal = [x for x in high_classification.get(leaf.taxon.label).get('tk_tax_terminal').split(
+                    ';')[0:self.order_rank.index(self.rank_of_interest) + 2] if len(x) > 3]
+                low_taxonomy = summary_row.classification.split(';')[0:len(fullrank_terminal)]
+
+                if fullrank_terminal != low_taxonomy:
+                    conflict_file.write(
+                        '{}\t{}\t{}\tterminal_classification\n'.format(leaf.taxon.label, high_classification.get(
+                            leaf.taxon.label).get('tk_tax_terminal'), summary_row.classification))
+
+                fullrank_red = [x for x in high_classification.get(leaf.taxon.label).get('tk_tax_red').split(
                     ';')[0:self.order_rank.index(self.rank_of_interest) + 2] if len(x) > 3]
-                low_taxonomy = summary_row.classification.split(';')[0:len(fullrank)]
-                if fullrank != low_taxonomy:
-                    conflict_file.write('{}\t{}\t{}\n'.format(leaf.taxon.label, high_classification.get(
-                        leaf.taxon.label).get('tk_tax'), summary_row.classification))
+                low_taxonomy = summary_row.classification.split(';')[0:len(fullrank_red)]
+
+                if fullrank_red != low_taxonomy:
+                    conflict_file.write(
+                        '{}\t{}\t{}\tred_classification\n'.format(leaf.taxon.label, high_classification.get(
+                            leaf.taxon.label).get('tk_tax_red'), summary_row.classification))
+
+    def generate_summary_row_reverse_to_backbone(self,standardised_red_tax, leaf, high_classification):
+        taxonomy_infos = high_classification.get(leaf.taxon.label)
+        common_ranks = [z for z in standardised_red_tax.split(';') if
+                        len(z) > 3 and z in taxonomy_infos.get('tk_tax_red').split(';')]
+        combined_ranks = standardise_taxonomy(';'.join(common_ranks), 'bac120')
+        summary_row = ClassifySummaryFileRow()
+        summary_row.gid = leaf.taxon.label
+        summary_row.classification = combined_ranks
+        summary_row.pplacer_tax = taxonomy_infos.get('pplacer_tax')
+        summary_row.red_value = taxonomy_infos.get('rel_dist')
+        return summary_row
+
+    def check_common_rank_btwn_tax(self,standardised_red_tax,taxonomy_infos,rank):
+        return (taxonomy_infos.get('tk_tax_red').split(';')[self.order_rank.index(rank)] != rank and
+        standardised_red_tax.split(';')[self.order_rank.index(rank)] != rank and
+        standardised_red_tax.split(';')[self.order_rank.index(rank)] != taxonomy_infos.get('tk_tax_red').split(';')[
+            self.order_rank.index(rank)])
 
     def _parse_tree(self, tree, genomes, msa_dict, percent_multihit_dict, trans_table_dict, bac_ar_diff,
                     user_msa_file, red_dict, summary_file, conflict_file, pplacer_taxonomy_dict, high_classification,
-                    debugfile, debugopt):
+                    debug_file, debugopt, tree_mapping_file, tree_iter, tree_mapping_dict_reverse):
         # Genomes can be classified by using FastANI or RED values
         # We go through all leaves of the tree. if the leaf is a user
         # genome we take its parent node and look at all the leaves
@@ -806,7 +930,7 @@ def _parse_tree(self, tree, genomes, msa_dict, percent_multihit_dict, trans_tabl
         tt = TreeTraversal()
 
         self.logger.log(Config.LOG_TASK, 'Traversing tree to determine classification method.')
-        fastani_verification = self._get_fastani_verification(tree, self.reference_ids, tt)
+        fastani_verification, qury_nodes = self._get_fastani_verification(tree, self.reference_ids, tt)
 
         # we run a fastani comparison for each user genomes against the
         # selected genomes in the same genus
@@ -827,34 +951,27 @@ def _parse_tree(self, tree, genomes, msa_dict, percent_multihit_dict, trans_tabl
         self.logger.info(f'{len(classified_user_genomes):,} genome(s) have '
                          f'been classified using FastANI and pplacer.')
 
+        if tree_mapping_file:
+            for genome in [x.taxon.label for x in qury_nodes]:
+                mapping_row = GenomeMappingFileRow()
+                mapping_row.gid = genome
+                if genome in classified_user_genomes:
+                    mapping_row.ani_classification = True
+                else:
+                    mapping_row.ani_classification = True
+                mapping_row.mapped_tree = tree_iter
+                tree_mapping_file.add_row(mapping_row)
+
         # Iterate over each leaf node that was not classified with FastANI.
+        order_in_spe_tree = None
+        if tree_mapping_dict_reverse:
+            order_in_spe_tree = tree_mapping_dict_reverse.get(tree_iter)
         self._classify_red_topology(tree, msa_dict, percent_multihit_dict,
                                     trans_table_dict, bac_ar_diff, user_msa_file,
                                     red_dict, summary_file, conflict_file,
                                     pplacer_taxonomy_dict, high_classification,
-                                    debugfile, debugopt, classified_user_genomes,
-                                    unclassified_user_genomes, tt)
-
-    def _map_high_taxonomy(self, high_classification, mapping_dict, summary_file):
-        mapped_rank = {}
-        counter = 0
-        for k, v in high_classification.items():
-            # if the classification has an order
-
-            rk_to_check = v.get('tk_tax').split(
-                ';')[self.order_rank.index(self.rank_of_interest)]
-            if len(rk_to_check) > 3:
-                mapped_rank.setdefault(
-                    mapping_dict.get(rk_to_check), []).append(k)
-                counter += 1
-            else:
-                summary_row = ClassifySummaryFileRow()
-                summary_row.gid = k
-                summary_row.classification = v.get('tk_tax')
-                summary_row.pplacer_tax = v.get('pplacer_tax')
-                summary_row.red_value = v.get('rel_dist')
-                summary_file.add_row(summary_row)
-        return mapped_rank, counter
+                                    debug_file, debugopt, classified_user_genomes,
+                                    unclassified_user_genomes, tt, order_in_spe_tree)
 
     def _assign_mrca_red(self, input_tree, marker_set_id, levelopt=None, tree_iter=None):
         """Parse the pplacer tree and write the partial taxonomy for each user genome based on their placements
@@ -862,7 +979,7 @@ def _assign_mrca_red(self, input_tree, marker_set_id, levelopt=None, tree_iter=N
         Parameters
         ----------
         input_tree : pplacer tree
-        marker_set_id : bacterial or archeal id (bac120 or ar122)
+        marker_set_id : bacterial or archeal id (bac120 or ar53)
 
         Returns
         -------
@@ -885,8 +1002,8 @@ def _assign_mrca_red(self, input_tree, marker_set_id, levelopt=None, tree_iter=N
             red_file = Config.HIGH_RED_FILE
         elif levelopt == 'low':
             red_file = Config.LOW_RED_FILE.format(iter=tree_iter)
-        if marker_set_id == 'ar122':
-            red_file = Config.MRCA_RED_AR122
+        if marker_set_id == 'ar53':
+            red_file = Config.MRCA_RED_AR53
 
         # create map from leave labels to tree nodes
         leaf_node_map = {}
@@ -913,6 +1030,8 @@ def _assign_mrca_red(self, input_tree, marker_set_id, levelopt=None, tree_iter=N
         # We only give RED value to added nodes placed on a reference edge ( between a reference parent and a reference child)
         # The new red value for the pplacer node =
         # RED_parent + (RED_child -RED_parent) * ( (pplacer_disttoroot - parent_disttoroot) / (child_disttoroot - parent_disttoroot) )
+
+        count = 0
         for nd in tree.leaf_nodes():
             if nd not in reference_nodes:
                 nd.rel_dist = 1.0
@@ -962,7 +1081,7 @@ def _get_pplacer_taxonomy(self, pplacer_classify_file, marker_set_id, user_msa_f
         Parameters
         ----------
         pplacer_classify_file : output file object to write
-        marker_set_id : bacterial or archaeal id (bac120 or ar122)
+        marker_set_id : bacterial or archaeal id (bac120 or ar53)
         user_msa_file : msa file listing all user genomes for a certain domain
         tree : pplacer tree including the user genomes
 
@@ -986,7 +1105,7 @@ def _get_pplacer_taxonomy(self, pplacer_classify_file, marker_set_id, user_msa_f
                     cur_node = cur_node.parent_node
                 taxa_str = ';'.join(taxa[::-1])
                 pplacer_classify_file.add_genome(leaf.taxon.label,
-                                                 self.standardise_taxonomy(taxa_str, marker_set_id))
+                                                 standardise_taxonomy(taxa_str, marker_set_id))
         pplacer_classify_file.write()
 
         return pplacer_classify_file.data
@@ -1032,15 +1151,19 @@ def _sort_fastani_results(self, fastani_verification, pplacer_taxonomy_dict,
 
         Parameters
         ----------
-        fastani_verification : dictionary listing the potential genomes associated with a user genome d[user_genome] = {"potential_g": [
-                                    (potential_genome_in_same_genus,patristic distance)], "pplacer_g": genome_of_reference_selected_by_pplacer(if any)}
-        all_fastani_dict : dictionary listing the fastani ANI for each user genomes against the potential genomes d[user_genome]={ref_genome1:{"af":af,"ani":ani},ref_genome2:{"af":af,"ani":ani}}
+        fastani_verification : dictionary listing the potential genomes associated with a user genome
+        d[user_genome] = {"potential_g": [(potential_genome_in_same_genus,patristic distance)],
+        "pplacer_g": genome_of_reference_selected_by_pplacer(if any)}
+        all_fastani_dict : dictionary listing the fastani ANI for each user genomes against the potential genomes
+        d[user_genome]={ref_genome1:{"af":af,"ani":ani},ref_genome2:{"af":af,"ani":ani}}
         summaryfout: output file
 
         Returns
         -------
-        classified_user_genomes: list of genomes where FastANI and Placement in the reference tree have predicted a taxonomy
-        unclassified_user_genomes: dictionary of genomes where FastANI and Placement in the reference tree have not  predicted a taxonomy
+        classified_user_genomes: list of genomes where FastANI and Placement in the reference tree have
+        predicted a taxonomy
+        unclassified_user_genomes: dictionary of genomes where FastANI and Placement in the reference tree have not
+        predicted a taxonomy
 
         """
         classified_user_genomes = []
@@ -1057,7 +1180,7 @@ def _sort_fastani_results(self, fastani_verification, pplacer_taxonomy_dict,
             if userleaf.taxon.label in bac_ar_diff:
                 notes.append('Genome domain questionable ( {}% Bacterial, {}% Archaeal)'.format(
                     bac_ar_diff.get(userleaf.taxon.label).get('bac120'),
-                    bac_ar_diff.get(userleaf.taxon.label).get('ar122')))
+                    bac_ar_diff.get(userleaf.taxon.label).get('ar53')))
 
             if potential_nodes.get("pplacer_g"):
                 pplacer_leafnode = potential_nodes.get("pplacer_g").taxon.label
@@ -1067,7 +1190,7 @@ def _sort_fastani_results(self, fastani_verification, pplacer_taxonomy_dict,
                     # import IPython; IPython.embed()
                     prefilter_af_reference_dictionary = {k: v for k, v in
                                                          all_fastani_dict.get(userleaf.taxon.label).items() if v.get(
-                                                             'af') >= self.af_threshold}
+                            'af') >= self.af_threshold}
                     sorted_prefilter_af_dict = sorted(iter(prefilter_af_reference_dictionary.items()),
                                                       key=lambda _x_y1: (_x_y1[1]['ani'], _x_y1[1]['af']), reverse=True)
 
@@ -1076,7 +1199,8 @@ def _sort_fastani_results(self, fastani_verification, pplacer_taxonomy_dict,
 
                     fastani_matching_reference = None
                     if len(sorted_prefilter_af_dict) > 0:
-                        if sorted_prefilter_af_dict[0][1].get('ani') >= self.species_radius.get(sorted_prefilter_af_dict[0][0]):
+                        if sorted_prefilter_af_dict[0][1].get('ani') >= self.species_radius.get(
+                                sorted_prefilter_af_dict[0][0]):
                             fastani_matching_reference = sorted_prefilter_af_dict[0][0]
                             current_ani = all_fastani_dict.get(userleaf.taxon.label).get(
                                 fastani_matching_reference).get('ani')
@@ -1110,7 +1234,7 @@ def _sort_fastani_results(self, fastani_verification, pplacer_taxonomy_dict,
                         if pplacer_leafnode == fastani_matching_reference:
                             if taxa_str.endswith("s__"):
                                 taxa_str = taxa_str + pplacer_leafnode
-                            summary_row.classification = self.standardise_taxonomy(
+                            summary_row.classification = standardise_taxonomy(
                                 taxa_str)
                             summary_row.closest_placement_ref = summary_row.fastani_ref
                             summary_row.closest_placement_radius = summary_row.fastani_ref_radius
@@ -1129,7 +1253,7 @@ def _sort_fastani_results(self, fastani_verification, pplacer_taxonomy_dict,
                         else:
                             taxa_str = ";".join(self.gtdb_taxonomy.get(
                                 add_ncbi_prefix(fastani_matching_reference)))
-                            summary_row.classification = self.standardise_taxonomy(
+                            summary_row.classification = standardise_taxonomy(
                                 taxa_str)
                             summary_row.closest_placement_ref = pplacer_leafnode
                             summary_row.closest_placement_radius = str(
@@ -1177,7 +1301,7 @@ def _sort_fastani_results(self, fastani_verification, pplacer_taxonomy_dict,
             elif userleaf.taxon.label in all_fastani_dict:
                 prefilter_af_reference_dictionary = {k: v for k, v in
                                                      all_fastani_dict.get(userleaf.taxon.label).items() if v.get(
-                                                         'af') >= self.af_threshold}
+                        'af') >= self.af_threshold}
                 sorted_prefilter_af_dict = sorted(iter(prefilter_af_reference_dictionary.items()),
                                                   key=lambda _x_y1: (_x_y1[1]['ani'], _x_y1[1]['af']), reverse=True)
                 sorted_dict = sorted(iter(all_fastani_dict.get(
@@ -1205,13 +1329,14 @@ def _sort_fastani_results(self, fastani_verification, pplacer_taxonomy_dict,
                     if len(notes) > 0:
                         summary_row.warnings = ';'.join(notes)
 
-                    if sorted_prefilter_af_dict[0][1].get('ani') >= self.species_radius.get(sorted_prefilter_af_dict[0][0]):
+                    if sorted_prefilter_af_dict[0][1].get('ani') >= self.species_radius.get(
+                            sorted_prefilter_af_dict[0][0]):
                         fastani_matching_reference = sorted_prefilter_af_dict[0][0]
                         exception_genomes.append(fastani_matching_reference)
 
                         taxa_str = ";".join(self.gtdb_taxonomy.get(
                             add_ncbi_prefix(fastani_matching_reference)))
-                        summary_row.classification = self.standardise_taxonomy(
+                        summary_row.classification = standardise_taxonomy(
                             taxa_str)
 
                         summary_row.fastani_ref = fastani_matching_reference
@@ -1280,7 +1405,7 @@ def _get_redtax(self, list_subnode, closest_rank):
             # otherwise it's stored as undefined
             # case a,b
             subtax.append(closest_rank + "undefined")
-        return ';'.join(subtax)
+        return subtax
 
     def _parse_subnodes(self, list_subnode, closest_rank):
         subtax = []
@@ -1674,10 +1799,18 @@ def _get_fastani_genome_path(self, fastani_verification, genomes):
                 shortleaf = leafnode.taxon.label
                 if leafnode.taxon.label.startswith('GB_') or leafnode.taxon.label.startswith('RS_'):
                     shortleaf = leafnode.taxon.label[3:]
-                ref_path = os.path.join(
-                    Config.FASTANI_GENOMES,
-                    self.parse_leaf_to_dir_path(shortleaf),
-                    shortleaf + Config.FASTANI_GENOMES_EXT)
+                # TODEL UBA genomes
+                if shortleaf.startswith("UBA"):
+                    ref_path = os.path.join(
+                        Config.FASTANI_GENOMES,
+                        'UBA',
+                        shortleaf + Config.FASTANI_GENOMES_EXT)
+                else:
+                    ref_path = os.path.join(
+                        Config.FASTANI_GENOMES,
+                        self.parse_leaf_to_dir_path(shortleaf),
+                        shortleaf + Config.FASTANI_GENOMES_EXT)
+
                 if not os.path.isfile(ref_path):
                     raise GTDBTkExit(f'Reference genome missing from FastANI database: {ref_path}')
 
@@ -1685,186 +1818,3 @@ def _get_fastani_genome_path(self, fastani_verification, genomes):
                 dict_paths[shortleaf] = ref_path
 
         return dict_compare, dict_paths
-
-    # FUNCTION FOR SPLIT Tree
-
-    def _get_high_pplacer_taxonomy(self, out_dir, marker_set_id, prefix, user_msa_file, tree):
-        """Parse the pplacer tree and write the partial taxonomy for each user genome based on their placements
-
-        Parameters
-        ----------
-        out_dir : output directory
-        prefix : desired prefix for output files
-        marker_set_id : bacterial or archeal id (bac120 or ar122)
-        user_msa_file : msa file listing all user genomes for a certain domain
-        tree : pplacer tree including the user genomes
-
-        Returns
-        -------
-        dictionary[genome_label]=pplacer_taxonomy
-
-        """
-        results = {}
-        out_root = os.path.join(out_dir, 'classify', 'intermediate_results')
-        make_sure_path_exists(out_root)
-        result = {}
-
-        if marker_set_id == 'bac120':
-            out_pplacer = os.path.join(
-                out_dir, PATH_BAC120_HIGH_PPLACER_CLASS.format(prefix=prefix))
-        # elif marker_set_id == 'ar122':
-        #     out_pplacer = os.path.join(
-        #         out_dir, PATH_AR122_PPLACER_CLASS.format(prefix=prefix))
-        else:
-            self.logger.error('There was an error determining the marker set.')
-            raise GenomeMarkerSetUnknown
-
-        marker_dict = Config.RED_DIST_BAC_DICT
-
-        # We get the pplacer taxonomy for comparison
-        count = 0
-        with open(out_pplacer, 'w') as pplaceout:
-            user_genome_ids = set(read_fasta(user_msa_file).keys())
-            for leaf in tree.leaf_node_iter():
-                is_on_terminal_branch = False
-                term_branch_taxonomy = ''
-                if leaf.taxon.label in user_genome_ids:
-                    count += 1
-                    taxa = []
-                    cur_node = leaf
-                    current_rel_dist = 1.0
-                    while cur_node.parent_node:
-                        if hasattr(cur_node, 'rel_dist') and current_rel_dist == 1.0 and cur_node.rel_dist < 1.0:
-                            current_rel_dist = cur_node.rel_dist
-                        if cur_node.is_internal():
-                            child_genomes = [nd.taxon.label
-                                             for nd in cur_node.leaf_nodes()
-                                             if nd.taxon.label not in user_genome_ids]
-                            if len(child_genomes) == 1:
-                                is_on_terminal_branch = True
-                                term_branch_taxonomy = self.gtdb_taxonomy.get(
-                                    child_genomes[0])
-
-                        _support, taxon, _aux_info = parse_label(
-                            cur_node.label)
-                        if taxon:
-                            for t in taxon.split(';')[::-1]:
-                                taxa.append(t.strip())
-                        cur_node = cur_node.parent_node
-
-                    taxa_str = ';'.join(taxa[::-1])
-                    pplacer_tax = str(taxa_str)
-
-                    if is_on_terminal_branch:
-                        tax_of_leaf = term_branch_taxonomy[term_branch_taxonomy.index(
-                            taxa_str.split(';')[-1]) + 1:-1]
-                        #print ('tax_of_leaf', tax_of_leaf)
-                        taxa_str = self._classify_on_terminal_branch(
-                            tax_of_leaf, current_rel_dist, taxa_str.split(';')[-1][0:3], term_branch_taxonomy, marker_dict)
-                    else:
-                        cur_node = leaf
-                        parent_taxon_node = cur_node.parent_node
-                        _support, parent_taxon, _aux_info = parse_label(
-                            parent_taxon_node.label)
-
-                        while parent_taxon_node is not None and not parent_taxon:
-                            parent_taxon_node = parent_taxon_node.parent_node
-                            _support, parent_taxon, _aux_info = parse_label(
-                                parent_taxon_node.label)
-
-                        # is the node represent multiple ranks, we select the lowest one
-                        # i.e. if node is p__A;c__B;o__C we pick o__
-                        parent_rank = parent_taxon.split(";")[-1][0:3]
-                        parent_rel_dist = parent_taxon_node.rel_dist
-
-                        if parent_rank != 'g__':
-                            node_in_ref_tree = cur_node
-                            while len([childnd.taxon.label.replace("'", '') for childnd in node_in_ref_tree.leaf_iter(
-                            ) if childnd.taxon.label[0:3] in ['RS_', 'UBA', 'GB_']]) == 0:
-                                node_in_ref_tree = node_in_ref_tree.parent_node
-                            # we select a node of the reference tree
-
-                            # we select the child rank (if parent_rank = 'c__'
-                            # child rank will be 'o__)'
-                            child_rk = self.order_rank[self.order_rank.index(
-                                parent_rank) + 1]
-
-                            # get all reference genomes under the current node
-                            list_subnode = [childnd.taxon.label.replace("'", '') for childnd in
-                                            node_in_ref_tree.leaf_iter()
-                                            if childnd.taxon.label[0:3] in ['RS_', 'UBA', 'GB_']]
-
-                            # get all names for the child rank
-                            list_ranks = [self.gtdb_taxonomy.get(name)[self.order_rank.index(child_rk)]
-                                          for name in list_subnode]
-
-                            # if there is just one rank name
-                            if len(set(list_ranks)) == 1:
-                                for subranknd in node_in_ref_tree.preorder_iter():
-                                    _support, subranknd_taxon, _aux_info = parse_label(
-                                        subranknd.label)
-                                    if subranknd.is_internal() and subranknd_taxon is not None and subranknd_taxon.startswith(
-                                            child_rk):
-                                        child_taxons = subranknd_taxon.split(
-                                            ";")
-                                        child_taxon_node = subranknd
-                                        child_rel_dist = child_taxon_node.rel_dist
-                                        break
-                                taxa_str = self._classify_on_internal_branch(
-                                    child_taxons, current_rel_dist, child_rel_dist, parent_rank, taxa_str, marker_dict)
-                    results[leaf.taxon.label] = {"tk_tax": self.standardise_taxonomy(taxa_str, 'bac120'),
-                                                 "pplacer_tax": self.standardise_taxonomy(pplacer_tax, 'bac120'), 'rel_dist': current_rel_dist}
-                    pplaceout.write('{}\t{}\t{}\t{}\t{}\n'.format(leaf.taxon.label, self.standardise_taxonomy(taxa_str, 'bac120'),
-                                                                  self.standardise_taxonomy(pplacer_tax, 'bac120'), is_on_terminal_branch, current_rel_dist))
-        return results
-
-    def _classify_on_internal_branch(self, child_taxons, current_rel_list, child_rel_dist, parent_rank, taxa_str, marker_dict):
-        # if there is multiple ranks on the child node (i.e genome between p__Nitrospirae and c__Nitrospiria;o__Nitrospirales;f__Nitropiraceae)
-        # we loop through the list of rank from f_ to c_ rank
-        closest_rank = None
-
-        for child_taxon in reversed(child_taxons):
-            # if lower rank is c__Nitropiria
-            if child_taxon == child_taxons[0]:
-                if (abs(current_rel_list - marker_dict.get(child_taxon[:3])) < abs(
-                        child_rel_dist - marker_dict.get(child_taxon[:3])) and
-                        abs(current_rel_list - marker_dict.get(child_taxon[:3])) < abs(
-                            current_rel_list - marker_dict.get(parent_rank))):
-                    closest_rank = child_taxon[:3]
-                elif closest_rank is None:
-                    closest_rank = parent_rank
-            else:
-                pchildrank = child_taxons[child_taxons.index(
-                    child_taxon) - 1]
-                if (abs(current_rel_list - marker_dict.get(child_taxon[:3])) < abs(
-                        current_rel_list - marker_dict.get(pchildrank[:3])) and
-                        abs(current_rel_list - marker_dict.get(child_taxon[:3])) < abs(
-                            child_rel_dist - marker_dict.get(child_taxon[:3]))):
-                    closest_rank = child_taxon
-                    break
-        if closest_rank is not None:
-            for k, v in self.gtdb_taxonomy.items():
-                if '{};'.format(closest_rank) in v:
-                    return ';'.join(v[1:v.index(closest_rank) + 1])
-        return taxa_str
-
-    def _classify_on_terminal_branch(self, list_leaf_ranks, current_rel_list, parent_rank, term_branch_taxonomy, marker_dict):
-        closest_rank = None
-        for leaf_taxon in reversed(list_leaf_ranks):
-            # print leaf_taxon
-            if leaf_taxon == list_leaf_ranks[0]:
-                if abs(current_rel_list - marker_dict.get(leaf_taxon[:3])) < abs(
-                        current_rel_list - marker_dict.get(parent_rank)):
-                    closest_rank = leaf_taxon[:3]
-                    break
-            else:
-                pchildrank = list_leaf_ranks[list_leaf_ranks.index(
-                    leaf_taxon) - 1]
-                # print leaf_taxon[:3]
-                if abs(current_rel_list - marker_dict.get(leaf_taxon[:3])) < abs(
-                        current_rel_list - marker_dict.get(pchildrank[:3])):
-                    closest_rank = leaf_taxon[:3]
-                    break
-        if closest_rank is None:
-            closest_rank = parent_rank
-        return ';'.join(term_branch_taxonomy[1:self.order_rank.index(closest_rank) + 1])
diff --git a/gtdbtk/cli.py b/gtdbtk/cli.py
index c4e2b7f6..5b31274b 100644
--- a/gtdbtk/cli.py
+++ b/gtdbtk/cli.py
@@ -4,7 +4,7 @@
 
 from gtdbtk.biolib_lite.custom_help_formatter import ChangeTempAction
 from gtdbtk.biolib_lite.custom_help_formatter import CustomHelpFormatter
-from gtdbtk.config.config import AF_THRESHOLD
+from gtdbtk.config.config import AF_THRESHOLD, PPLACER_MIN_RAM_BAC
 
 
 @contextmanager
@@ -31,8 +31,14 @@ def __temp_dir(group):
                        help="specify alternative directory for temporary files")
 
 
+def __genes(group):
+    group.add_argument('--genes', action='store_true', default=False,
+                       help='indicates input files contain called genes (skip gene calling)')
+
+
 def __genome_dir(group):
-    group.add_argument('--genome_dir', help="directory containing genome files in FASTA format")
+    group.add_argument(
+        '--genome_dir', help="directory containing genome files in FASTA format")
 
 
 def __batchfile(group):
@@ -153,7 +159,8 @@ def __prefix(group):
 
 
 def __cpus(group):
-    group.add_argument('--cpus', default=1, type=int, help='number of CPUs to use')
+    group.add_argument('--cpus', default=1, type=int,
+                       help='number of CPUs to use')
 
 
 def __force(group):
@@ -172,12 +179,12 @@ def __help(group):
 
 def __pplacer_cpus(group):
     group.add_argument('--pplacer_cpus', type=int, default=None,
-                       help='use ``pplacer_cpus`` during placement (default: ``cpus``)')
+                       help='number of CPUs to use during pplacer placement')
 
 
 def __scratch_dir(group):
     group.add_argument('--scratch_dir', type=str, default=None,
-                       help='Reduce pplacer memory usage by writing to disk (slower).')
+                       help='reduce pplacer memory usage by writing to disk (slower).')
 
 
 def __recalculate_red(group):
@@ -185,9 +192,10 @@ def __recalculate_red(group):
                        help='recalculate RED values based on the reference tree and all added user genomes')
 
 
-def __split_tree(group):
-    group.add_argument('-s', '--split_tree', default=False, action='store_true',
-                       help='Use shards of the reference tree (for Bacteria only). reduce memory usage (slower).')
+def __full_tree(group):
+    group.add_argument('-f', '--full_tree', default=False, action='store_true',
+                       help='use the unsplit bacterial tree for the classify step; this is the original GTDB-Tk '
+                            f'approach (version < 2) and requires more than {PPLACER_MIN_RAM_BAC} GB of RAM to load the reference tree')
 
 
 def __identify_dir(group, required):
@@ -237,19 +245,23 @@ def __no_mash(group):
 
 
 def __mash_k(group):
-    group.add_argument('--mash_k', default=16, type=int, help='k-mer size [1-32]')
+    group.add_argument('--mash_k', default=16, type=int,
+                       help='k-mer size [1-32]')
 
 
 def __mash_s(group):
-    group.add_argument('--mash_s', default=5000, type=int, help='maximum number of non-redundant hashes')
+    group.add_argument('--mash_s', default=5000, type=int,
+                       help='maximum number of non-redundant hashes')
 
 
 def __mash_d(group):
-    group.add_argument('--mash_d', default=0.1, type=float, help='maximum distance to keep [0-1]')
+    group.add_argument('--mash_d', default=0.1, type=float,
+                       help='maximum distance to keep [0-1]')
 
 
 def __mash_v(group):
-    group.add_argument('--mash_v', default=1.0, type=float, help='maximum p-value to keep [0-1]')
+    group.add_argument('--mash_v', default=1.0, type=float,
+                       help='maximum p-value to keep [0-1]')
 
 
 def __mash_db(group):
@@ -259,7 +271,7 @@ def __mash_db(group):
 
 def __min_af(group):
     group.add_argument('--min_af', type=float, default=AF_THRESHOLD,
-                       help='minimum alignment fraction to consider closest genome')
+                       help='minimum alignment fraction to assign genome to a species cluster')
 
 
 def __untrimmed_msa(group, required):
@@ -267,6 +279,11 @@ def __untrimmed_msa(group, required):
                        help="path to the untrimmed MSA file")
 
 
+def __keep_intermediates(group):
+    group.add_argument('--keep_intermediates', default=False, action='store_true',
+                       help='keep intermediate files in the final directory')
+
+
 def __output(group, required):
     group.add_argument('--output', type=str, default=None, required=required,
                        help='output file')
@@ -295,7 +312,8 @@ def __write_single_copy_genes(group):
 
 def get_main_parser():
     # Setup the main, and sub parsers.
-    main_parser = argparse.ArgumentParser(prog='gtdbtk', add_help=False, conflict_handler='resolve')
+    main_parser = argparse.ArgumentParser(
+        prog='gtdbtk', add_help=False, conflict_handler='resolve')
     sub_parsers = main_parser.add_subparsers(help="--", dest='subparser_name')
 
     # de novo workflow.
@@ -326,9 +344,11 @@ def get_main_parser():
             __gtdbtk_classification_file(grp)
             __custom_taxonomy_file(grp)
             __prefix(grp)
+            __genes(grp)
             __cpus(grp)
             __force(grp)
             __temp_dir(grp)
+            __keep_intermediates(grp)
             __debug(grp)
             __help(grp)
 
@@ -340,15 +360,17 @@ def get_main_parser():
         with arg_group(parser, 'required named arguments') as grp:
             __out_dir(grp, required=True)
         with arg_group(parser, 'optional arguments') as grp:
+            __full_tree(grp)
             __extension(grp)
             __min_perc_aa(grp)
             __prefix(grp)
+            __genes(grp)
             __cpus(grp)
             __pplacer_cpus(grp)
             __force(grp)
             __scratch_dir(grp)
             # __recalculate_red(grp)
-            # __split_tree(grp)
+            __keep_intermediates(grp)
             __min_af(grp)
             __temp_dir(grp)
             __debug(grp)
@@ -364,6 +386,7 @@ def get_main_parser():
         with arg_group(parser, 'optional arguments') as grp:
             __extension(grp)
             __prefix(grp)
+            __genes(grp)
             __cpus(grp)
             __force(grp)
             __write_single_copy_genes(grp)
@@ -423,7 +446,7 @@ def get_main_parser():
             __cpus(grp)
             __pplacer_cpus(grp)
             __scratch_dir(grp)
-            # __split_tree(grp)
+            __full_tree(grp)
             # __recalculate_red(grp)
             __min_af(grp)
             __temp_dir(grp)
@@ -510,6 +533,25 @@ def get_main_parser():
             __debug(grp)
             __help(grp)
 
+    # Remove labels
+    with subparser(sub_parsers, 'remove_labels', 'Remove labels (bootstrap values, node labels) from an Newick tree to '
+                                                 'to improve compatibility with tree viewers.') as parser:
+        with arg_group(parser, 'required named arguments') as grp:
+            __input_tree(grp, required=True)
+            __output_tree(grp, required=True)
+        with arg_group(parser, 'optional arguments') as grp:
+            __debug(grp)
+            __help(grp)
+
+    # Remove labels
+    with subparser(sub_parsers, 'convert_to_itol', 'Reformat the GTDB-Tk tree to be iTOL compatible.') as parser:
+        with arg_group(parser, 'required named arguments') as grp:
+            __input_tree(grp, required=True)
+            __output_tree(grp, required=True)
+        with arg_group(parser, 'optional arguments') as grp:
+            __debug(grp)
+            __help(grp)
+
     # Export MSA.
     with subparser(sub_parsers, 'export_msa', 'Export the untrimmed archaeal or bacterial MSA file.') as parser:
         with arg_group(parser, 'required named arguments') as grp:
diff --git a/gtdbtk/config/config.py b/gtdbtk/config/config.py
index bfec3d71..0238fbe2 100644
--- a/gtdbtk/config/config.py
+++ b/gtdbtk/config/config.py
@@ -45,7 +45,7 @@
 
 LOW_TREE_MAPPING_FILE = os.path.join(LOW_SPLIT_DIR, 'tree_mapping.tsv')
 
-HIGH_PPLACER_REF_PKG = 'gtdbtk_package_high_level'
+HIGH_PPLACER_REF_PKG = 'gtdbtk_package_backbone.refpkg'
 HIGH_RED_FILE = os.path.join(HIGH_RED_DIR, 'high_red_value.tsv')
 LOW_PPLACER_REF_PKG = os.path.join(LOW_PPLACER_DIR, 'gtdbtk.package.{iter}.refpkg')
 LOW_RED_FILE = os.path.join(LOW_RED_DIR, 'red_value_{iter}.tsv')
@@ -83,6 +83,91 @@
 RED_MIN_CHILDREN = 2
 
 # Marker information
+# Marker information TO DELETE , This is only temporary
+# BAC120_MARKERS = {"PFAM": ["PF00380.14.hmm", "PF00410.14.hmm", "PF00466.15.hmm",
+#                            "PF01025.14.hmm", "PF02576.12.hmm", "PF03726.9.hmm"],
+#                   "TIGRFAM": ["TIGR00006.HMM", "TIGR00019.HMM", "TIGR00020.HMM",
+#                               "TIGR00029.HMM", "TIGR00043.HMM", "TIGR00054.HMM",
+#                               "TIGR00059.HMM", "TIGR00061.HMM", "TIGR00064.HMM",
+#                               "TIGR00065.HMM", "TIGR00082.HMM", "TIGR00083.HMM",
+#                               "TIGR00084.HMM", "TIGR00086.HMM", "TIGR00088.HMM",
+#                               "TIGR00090.HMM", "TIGR00092.HMM", "TIGR00095.HMM",
+#                               "TIGR00115.HMM", "TIGR00116.HMM", "TIGR00138.HMM",
+#                               "TIGR00158.HMM", "TIGR00166.HMM", "TIGR00168.HMM",
+#                               "TIGR00186.HMM", "TIGR00194.HMM", "TIGR00250.HMM",
+#                               "TIGR00337.HMM", "TIGR00344.HMM", "TIGR00362.HMM",
+#                               "TIGR00382.HMM", "TIGR00392.HMM", "TIGR00396.HMM",
+#                               "TIGR00398.HMM", "TIGR00414.HMM", "TIGR00416.HMM",
+#                               "TIGR00420.HMM", "TIGR00431.HMM", "TIGR00435.HMM",
+#                               "TIGR00436.HMM", "TIGR00442.HMM", "TIGR00445.HMM",
+#                               "TIGR00456.HMM", "TIGR00459.HMM", "TIGR00460.HMM",
+#                               "TIGR00468.HMM", "TIGR00472.HMM", "TIGR00487.HMM",
+#                               "TIGR00496.HMM", "TIGR00539.HMM", "TIGR00580.HMM",
+#                               "TIGR00593.HMM", "TIGR00615.HMM", "TIGR00631.HMM",
+#                               "TIGR00634.HMM", "TIGR00635.HMM", "TIGR00643.HMM",
+#                               "TIGR00663.HMM", "TIGR00717.HMM", "TIGR00755.HMM",
+#                               "TIGR00810.HMM", "TIGR00922.HMM", "TIGR00928.HMM",
+#                               "TIGR00959.HMM", "TIGR00963.HMM", "TIGR00964.HMM",
+#                               "TIGR00967.HMM", "TIGR01009.HMM", "TIGR01011.HMM",
+#                               "TIGR01017.HMM", "TIGR01021.HMM", "TIGR01029.HMM",
+#                               "TIGR01032.HMM", "TIGR01039.HMM", "TIGR01044.HMM",
+#                               "TIGR01059.HMM", "TIGR01063.HMM", "TIGR01066.HMM",
+#                               "TIGR01071.HMM", "TIGR01079.HMM", "TIGR01082.HMM",
+#                               "TIGR01087.HMM", "TIGR01128.HMM", "TIGR01146.HMM",
+#                               "TIGR01164.HMM", "TIGR01169.HMM", "TIGR01171.HMM",
+#                               "TIGR01302.HMM", "TIGR01391.HMM", "TIGR01393.HMM",
+#                               "TIGR01394.HMM", "TIGR01510.HMM", "TIGR01632.HMM",
+#                               "TIGR01951.HMM", "TIGR01953.HMM", "TIGR02012.HMM",
+#                               "TIGR02013.HMM", "TIGR02027.HMM", "TIGR02075.HMM",
+#                               "TIGR02191.HMM", "TIGR02273.HMM", "TIGR02350.HMM",
+#                               "TIGR02386.HMM", "TIGR02397.HMM", "TIGR02432.HMM",
+#                               "TIGR02729.HMM", "TIGR03263.HMM", "TIGR03594.HMM",
+#                               "TIGR03625.HMM", "TIGR03632.HMM", "TIGR03654.HMM",
+#                               "TIGR03723.HMM", "TIGR03725.HMM", "TIGR03953.HMM"]}
+
+# AR53_MARKERS = {"PFAM": ["PF01868.11.hmm", "PF01282.14.hmm", "PF01655.13.hmm",
+#                           "PF01092.14.hmm", "PF01000.21.hmm", "PF00368.13.hmm",
+#                           "PF00827.12.hmm", "PF01269.12.hmm", "PF00466.15.hmm",
+#                           "PF01015.13.hmm", "PF13685.1.hmm", "PF02978.14.hmm",
+#                           "PF04919.7.hmm", "PF01984.15.hmm", "PF04104.9.hmm",
+#                           "PF00410.14.hmm", "PF01798.13.hmm", "PF01864.12.hmm",
+#                           "PF01990.12.hmm", "PF07541.7.hmm", "PF04019.7.hmm",
+#                           "PF00900.15.hmm", "PF01090.14.hmm", "PF02006.11.hmm",
+#                           "PF01157.13.hmm", "PF01191.14.hmm", "PF01866.12.hmm",
+#                           "PF01198.14.hmm", "PF01496.14.hmm", "PF00687.16.hmm",
+#                           "PF03874.11.hmm", "PF01194.12.hmm", "PF01200.13.hmm",
+#                           "PF13656.1.hmm", "PF01280.15.hmm"],
+#                  "TIGRFAM": ["TIGR00468.HMM", "TIGR01060.HMM", "TIGR03627.HMM",
+#                              "TIGR01020.HMM", "TIGR02258.HMM", "TIGR00293.HMM",
+#                              "TIGR00389.HMM", "TIGR01012.HMM", "TIGR00490.HMM",
+#                              "TIGR03677.HMM", "TIGR03636.HMM", "TIGR03722.HMM",
+#                              "TIGR00458.HMM", "TIGR00291.HMM", "TIGR00670.HMM",
+#                              "TIGR00064.HMM", "TIGR03629.HMM", "TIGR00021.HMM",
+#                              "TIGR03672.HMM", "TIGR00111.HMM", "TIGR03684.HMM",
+#                              "TIGR01077.HMM", "TIGR01213.HMM", "TIGR01080.HMM",
+#                              "TIGR00501.HMM", "TIGR00729.HMM", "TIGR01038.HMM",
+#                              "TIGR00270.HMM", "TIGR03628.HMM", "TIGR01028.HMM",
+#                              "TIGR00521.HMM", "TIGR03671.HMM", "TIGR00240.HMM",
+#                              "TIGR02390.HMM", "TIGR02338.HMM", "TIGR00037.HMM",
+#                              "TIGR02076.HMM", "TIGR00335.HMM", "TIGR01025.HMM",
+#                              "TIGR00471.HMM", "TIGR00336.HMM", "TIGR00522.HMM",
+#                              "TIGR02153.HMM", "TIGR02651.HMM", "TIGR03674.HMM",
+#                              "TIGR00323.HMM", "TIGR00134.HMM", "TIGR02236.HMM",
+#                              "TIGR03683.HMM", "TIGR00491.HMM", "TIGR00658.HMM",
+#                              "TIGR03680.HMM", "TIGR00392.HMM", "TIGR00422.HMM",
+#                              "TIGR00279.HMM", "TIGR01052.HMM", "TIGR00442.HMM",
+#                              "TIGR00308.HMM", "TIGR00398.HMM", "TIGR00456.HMM",
+#                              "TIGR00549.HMM", "TIGR00408.HMM", "TIGR00432.HMM",
+#                              "TIGR00264.HMM", "TIGR00982.HMM", "TIGR00324.HMM",
+#                              "TIGR01952.HMM", "TIGR03626.HMM", "TIGR03670.HMM",
+#                              "TIGR00337.HMM", "TIGR01046.HMM", "TIGR01018.HMM",
+#                              "TIGR00936.HMM", "TIGR00463.HMM", "TIGR01309.HMM",
+#                              "TIGR03653.HMM", "TIGR00042.HMM", "TIGR02389.HMM",
+#                              "TIGR00307.HMM", "TIGR03673.HMM", "TIGR00373.HMM",
+#                              "TIGR01008.HMM", "TIGR00283.HMM", "TIGR00425.HMM",
+#                              "TIGR00405.HMM", "TIGR03665.HMM", "TIGR00448.HMM"]}
+
+
 BAC120_MARKERS = {"PFAM": ["PF00380.20.hmm", "PF00410.20.hmm", "PF00466.21.hmm",
                            "PF01025.20.hmm", "PF02576.18.hmm", "PF03726.15.hmm"],
                   "TIGRFAM": ["TIGR00006.HMM", "TIGR00019.HMM", "TIGR00020.HMM",
@@ -124,62 +209,83 @@
                               "TIGR03625.HMM", "TIGR03632.HMM", "TIGR03654.HMM",
                               "TIGR03723.HMM", "TIGR03725.HMM", "TIGR03953.HMM"]}
 
-AR122_MARKERS = {"PFAM": ["PF01868.17.hmm", "PF01282.20.hmm", "PF01655.19.hmm",
-                          "PF01092.20.hmm", "PF01000.27.hmm", "PF00368.19.hmm",
-                          "PF00827.18.hmm", "PF01269.18.hmm", "PF00466.21.hmm",
-                          "PF01015.19.hmm", "PF13685.7.hmm", "PF02978.20.hmm",
-                          "PF04919.13.hmm", "PF01984.21.hmm", "PF04104.15.hmm",
-                          "PF00410.20.hmm", "PF01798.19.hmm", "PF01864.18.hmm",
-                          "PF01990.18.hmm", "PF07541.13.hmm", "PF04019.13.hmm",
-                          "PF00900.21.hmm", "PF01090.20.hmm", "PF02006.17.hmm",
-                          "PF01157.19.hmm", "PF01191.20.hmm", "PF01866.18.hmm",
-                          "PF01198.20.hmm", "PF01496.20.hmm", "PF00687.22.hmm",
-                          "PF03874.17.hmm", "PF01194.18.hmm", "PF01200.19.hmm",
-                          "PF13656.7.hmm", "PF01280.21.hmm"],
-                 "TIGRFAM": ["TIGR00468.HMM", "TIGR01060.HMM", "TIGR03627.HMM",
-                             "TIGR01020.HMM", "TIGR02258.HMM", "TIGR00293.HMM",
-                             "TIGR00389.HMM", "TIGR01012.HMM", "TIGR00490.HMM",
-                             "TIGR03677.HMM", "TIGR03636.HMM", "TIGR03722.HMM",
-                             "TIGR00458.HMM", "TIGR00291.HMM", "TIGR00670.HMM",
-                             "TIGR00064.HMM", "TIGR03629.HMM", "TIGR00021.HMM",
-                             "TIGR03672.HMM", "TIGR00111.HMM", "TIGR03684.HMM",
-                             "TIGR01077.HMM", "TIGR01213.HMM", "TIGR01080.HMM",
-                             "TIGR00501.HMM", "TIGR00729.HMM", "TIGR01038.HMM",
-                             "TIGR00270.HMM", "TIGR03628.HMM", "TIGR01028.HMM",
-                             "TIGR00521.HMM", "TIGR03671.HMM", "TIGR00240.HMM",
-                             "TIGR02390.HMM", "TIGR02338.HMM", "TIGR00037.HMM",
-                             "TIGR02076.HMM", "TIGR00335.HMM", "TIGR01025.HMM",
-                             "TIGR00471.HMM", "TIGR00336.HMM", "TIGR00522.HMM",
-                             "TIGR02153.HMM", "TIGR02651.HMM", "TIGR03674.HMM",
-                             "TIGR00323.HMM", "TIGR00134.HMM", "TIGR02236.HMM",
-                             "TIGR03683.HMM", "TIGR00491.HMM", "TIGR00658.HMM",
-                             "TIGR03680.HMM", "TIGR00392.HMM", "TIGR00422.HMM",
-                             "TIGR00279.HMM", "TIGR01052.HMM", "TIGR00442.HMM",
-                             "TIGR00308.HMM", "TIGR00398.HMM", "TIGR00456.HMM",
-                             "TIGR00549.HMM", "TIGR00408.HMM", "TIGR00432.HMM",
-                             "TIGR00264.HMM", "TIGR00982.HMM", "TIGR00324.HMM",
-                             "TIGR01952.HMM", "TIGR03626.HMM", "TIGR03670.HMM",
-                             "TIGR00337.HMM", "TIGR01046.HMM", "TIGR01018.HMM",
-                             "TIGR00936.HMM", "TIGR00463.HMM", "TIGR01309.HMM",
-                             "TIGR03653.HMM", "TIGR00042.HMM", "TIGR02389.HMM",
-                             "TIGR00307.HMM", "TIGR03673.HMM", "TIGR00373.HMM",
-                             "TIGR01008.HMM", "TIGR00283.HMM", "TIGR00425.HMM",
-                             "TIGR00405.HMM", "TIGR03665.HMM", "TIGR00448.HMM"]}
+#
+# #New Version of AR53_MARKERS
+# AR53_MARKERS = {"PFAM": ["PF01868.17.hmm", "PF01282.20.hmm", "PF01655.19.hmm",
+#                           "PF01092.20.hmm", "PF01000.27.hmm", "PF00368.19.hmm",
+#                           "PF00827.18.hmm", "PF01269.18.hmm", "PF00466.21.hmm",
+#                           "PF01015.19.hmm", "PF13685.7.hmm", "PF02978.20.hmm",
+#                           "PF04919.13.hmm", "PF01984.21.hmm", "PF04104.15.hmm",
+#                           "PF00410.20.hmm", "PF01798.19.hmm", "PF01864.18.hmm",
+#                           "PF01990.18.hmm", "PF07541.13.hmm", "PF04019.13.hmm",
+#                           "PF00900.21.hmm", "PF01090.20.hmm", "PF02006.17.hmm",
+#                           "PF01157.19.hmm", "PF01191.20.hmm", "PF01866.18.hmm",
+#                           "PF01198.20.hmm", "PF01496.20.hmm", "PF00687.22.hmm",
+#                           "PF03874.17.hmm", "PF01194.18.hmm", "PF01200.19.hmm",
+#                           "PF13656.7.hmm", "PF01280.21.hmm"],
+#                  "TIGRFAM": ["TIGR00468.HMM", "TIGR01060.HMM", "TIGR03627.HMM",
+#                              "TIGR01020.HMM", "TIGR02258.HMM", "TIGR00293.HMM",
+#                              "TIGR00389.HMM", "TIGR01012.HMM", "TIGR00490.HMM",
+#                              "TIGR03677.HMM", "TIGR03636.HMM", "TIGR03722.HMM",
+#                              "TIGR00458.HMM", "TIGR00291.HMM", "TIGR00670.HMM",
+#                              "TIGR00064.HMM", "TIGR03629.HMM", "TIGR00021.HMM",
+#                              "TIGR03672.HMM", "TIGR00111.HMM", "TIGR03684.HMM",
+#                              "TIGR01077.HMM", "TIGR01213.HMM", "TIGR01080.HMM",
+#                              "TIGR00501.HMM", "TIGR00729.HMM", "TIGR01038.HMM",
+#                              "TIGR00270.HMM", "TIGR03628.HMM", "TIGR01028.HMM",
+#                              "TIGR00521.HMM", "TIGR03671.HMM", "TIGR00240.HMM",
+#                              "TIGR02390.HMM", "TIGR02338.HMM", "TIGR00037.HMM",
+#                              "TIGR02076.HMM", "TIGR00335.HMM", "TIGR01025.HMM",
+#                              "TIGR00471.HMM", "TIGR00336.HMM", "TIGR00522.HMM",
+#                              "TIGR02153.HMM", "TIGR02651.HMM", "TIGR03674.HMM",
+#                              "TIGR00323.HMM", "TIGR00134.HMM", "TIGR02236.HMM",
+#                              "TIGR03683.HMM", "TIGR00491.HMM", "TIGR00658.HMM",
+#                              "TIGR03680.HMM", "TIGR00392.HMM", "TIGR00422.HMM",
+#                              "TIGR00279.HMM", "TIGR01052.HMM", "TIGR00442.HMM",
+#                              "TIGR00308.HMM", "TIGR00398.HMM", "TIGR00456.HMM",
+#                              "TIGR00549.HMM", "TIGR00408.HMM", "TIGR00432.HMM",
+#                              "TIGR00264.HMM", "TIGR00982.HMM", "TIGR00324.HMM",
+#                              "TIGR01952.HMM", "TIGR03626.HMM", "TIGR03670.HMM",
+#                              "TIGR00337.HMM", "TIGR01046.HMM", "TIGR01018.HMM",
+#                              "TIGR00936.HMM", "TIGR00463.HMM", "TIGR01309.HMM",
+#                              "TIGR03653.HMM", "TIGR00042.HMM", "TIGR02389.HMM",
+#                              "TIGR00307.HMM", "TIGR03673.HMM", "TIGR00373.HMM",
+#                              "TIGR01008.HMM", "TIGR00283.HMM", "TIGR00425.HMM",
+#                              "TIGR00405.HMM", "TIGR03665.HMM", "TIGR00448.HMM"]}
+
+#New Version of AR53_MARKERS
+AR53_MARKERS = {"PFAM": ["PF04919.13.hmm","PF07541.13.hmm","PF01000.27.hmm",
+"PF00687.22.hmm","PF00466.21.hmm","PF00827.18.hmm","PF01280.21.hmm","PF01090.20.hmm",
+"PF01200.19.hmm","PF01015.19.hmm","PF00900.21.hmm","PF00410.20.hmm"],
+"TIGRFAM":["TIGR00037.HMM","TIGR00064.HMM","TIGR00111.HMM",
+"TIGR00134.HMM","TIGR00279.HMM","TIGR00291.HMM","TIGR00323.HMM",
+"TIGR00335.HMM","TIGR00373.HMM","TIGR00405.HMM","TIGR00448.HMM",
+"TIGR00483.HMM","TIGR00491.HMM","TIGR00522.HMM","TIGR00967.HMM",
+"TIGR00982.HMM","TIGR01008.HMM","TIGR01012.HMM","TIGR01018.HMM",
+"TIGR01020.HMM","TIGR01028.HMM","TIGR01046.HMM","TIGR01052.HMM",
+"TIGR01171.HMM","TIGR01213.HMM","TIGR01952.HMM","TIGR02236.HMM",
+"TIGR02338.HMM","TIGR02389.HMM","TIGR02390.HMM","TIGR03626.HMM",
+"TIGR03627.HMM","TIGR03628.HMM","TIGR03629.HMM","TIGR03670.HMM",
+"TIGR03671.HMM","TIGR03672.HMM","TIGR03673.HMM","TIGR03674.HMM",
+"TIGR03676.HMM","TIGR03680.HMM"]}
+
+
+
 
 # Information for Multiple hits markers:
 DEFAULT_MULTIHIT_THRESHOLD = 10.0
 
 # Information for aligning genomes
 DEFAULT_DOMAIN_THRESHOLD = 10.0
-AR_MARKER_COUNT = 122
+AR_MARKER_COUNT = 53
 BAC_MARKER_COUNT = 120
 
 # Information about alignment Fraction to resolve fastANI results
-AF_THRESHOLD = 0.65
+AF_THRESHOLD = 0.5
 
 # MSA file names
 CONCAT_BAC120 = os.path.join(MSA_FOLDER, f"gtdb_{VERSION_DATA}_bac120.faa")
-CONCAT_AR122 = os.path.join(MSA_FOLDER, f"gtdb_{VERSION_DATA}_ar122.faa")
+CONCAT_AR53 = os.path.join(MSA_FOLDER, f"gtdb_{VERSION_DATA}_ar53.faa")
 
 # Taxonomy file name
 TAXONOMY_FILE = os.path.join(TAX_FOLDER, "gtdb_taxonomy.tsv")
@@ -189,15 +295,15 @@
 
 # Mask file names
 MASK_BAC120 = f"gtdb_{VERSION_DATA}_bac120.mask"
-MASK_AR122 = f"gtdb_{VERSION_DATA}_ar122.mask"
+MASK_AR53 = f"gtdb_{VERSION_DATA}_ar53.mask"
 MASK_RPS23 = f"gtdb_{VERSION_DATA}_rps23.mask"
 
 # Pplacer configuration
 PPLACER_BAC120_REF_PKG = f"gtdb_{VERSION_DATA}_bac120.refpkg"
-PPLACER_AR122_REF_PKG = f"gtdb_{VERSION_DATA}_ar122.refpkg"
+PPLACER_AR53_REF_PKG = f"gtdb_{VERSION_DATA}_ar53.refpkg"
 PPLACER_RPS23_REF_PKG = f"gtdb_{VERSION_DATA}_rps23.refpkg"
-PPLACER_MIN_RAM_BAC = 215
-PPLACER_MIN_RAM_ARC = 13
+PPLACER_MIN_RAM_BAC = 320
+PPLACER_MIN_RAM_ARC = 40
 
 # Fastani configuration
 FASTANI_SPECIES_THRESHOLD = 95.0
@@ -207,18 +313,18 @@
 
 # MRCA RED VALUE
 MRCA_RED_BAC120 = os.path.join(RED_DIR, f"gtdbtk_{VERSION_DATA}_bac120.tsv")
-MRCA_RED_AR122 = os.path.join(RED_DIR, f"gtdbtk_{VERSION_DATA}_ar122.tsv")
+MRCA_RED_AR53 = os.path.join(RED_DIR, f"gtdbtk_{VERSION_DATA}_ar53.tsv")
 
 # Hashing information for validating the reference package.
-REF_HASHES = {PPLACER_DIR: '4d931b5109a240602f55228029b87ee768da8141',
-              MASK_DIR: '36d6ac371d247b2b952523b9798e78908ea323fa',
-              MARKER_DIR: '2ba5ae35fb272462663651d18fd9e523317e48cd',
-              RADII_DIR: '9f9a2e21e27b9049044d04d731795499414a365c',
-              MSA_FOLDER: 'b426865245c39ee9f01b0392fb8f7867a9f76f0a',
-              METADATA_DIR: '7640aed96fdb13707a2b79b746a94335faabd6df',
-              TAX_FOLDER: '4a7a1e4047c088e92dee9740206499cdb7e5beca',
-              FASTANI_DIR: '70439cf088d0fa0fdbb4f47b4a6b47e199912139',
-              RED_DIR: 'ad6a184150e7b6e58547912660a17999fadcfbff'}
+REF_HASHES = {PPLACER_DIR: '20903925a856a58b102a7b0ce160c5cbd2cf675b',
+              MASK_DIR: '50e414a9de18170e8cb97f990f89ff60a0fe29d5',
+              MARKER_DIR: '163f542c3f0a40f59df45d453aa235b39aa96e27',
+              RADII_DIR: '8fd13b1c5d7a7b073ba96fb628581613b293a374',
+              MSA_FOLDER: '24f250d7cf0eb0bc65dccd2f3c9247e553ea322f',
+              METADATA_DIR: '9772fbeac1311b31e10293fa610eb33aa1ec8e15',
+              TAX_FOLDER: '6fb0233b05633242369b40c026fd1ee53e266afa',
+              FASTANI_DIR: '973c456c02f55bb82908a6811c7076e207e9b206',
+              RED_DIR: '7b8b67b3157204b470c9eb809d3c39c4effffabc'}
 
 # Config values for checking GTDB-Tk on startup.
 GTDBTK_VER_CHECK = True
diff --git a/gtdbtk/config/output.py b/gtdbtk/config/output.py
index 7af03915..b949a4b1 100644
--- a/gtdbtk/config/output.py
+++ b/gtdbtk/config/output.py
@@ -6,7 +6,7 @@
 DIR_MARKER_GENE = join(DIR_IDENTIFY_INTERMEDIATE, 'marker_genes')
 DIR_IDENTIFY_FASTA = join(DIR_IDENTIFY_INTERMEDIATE, 'single_copy_fasta')
 PATH_BAC120_MARKER_SUMMARY = join(DIR_IDENTIFY, '{prefix}.bac120.markers_summary.tsv')
-PATH_AR122_MARKER_SUMMARY = join(DIR_IDENTIFY, '{prefix}.ar122.markers_summary.tsv')
+PATH_AR53_MARKER_SUMMARY = join(DIR_IDENTIFY, '{prefix}.ar53.markers_summary.tsv')
 PATH_TLN_TABLE_SUMMARY = join(DIR_IDENTIFY, '{prefix}.translation_table_summary.tsv')
 PATH_FAILS = join(DIR_IDENTIFY,'{prefix}.failed_genomes.tsv')
 
@@ -26,40 +26,44 @@
 DIR_ALIGN = 'align'
 DIR_ALIGN_INTERMEDIATE = join(DIR_ALIGN, 'intermediate_results')
 PATH_BAC120_FILTERED_GENOMES = join(DIR_ALIGN, '{prefix}.bac120.filtered.tsv')
-PATH_AR122_FILTERED_GENOMES = join(DIR_ALIGN, '{prefix}.ar122.filtered.tsv')
+PATH_AR53_FILTERED_GENOMES = join(DIR_ALIGN, '{prefix}.ar53.filtered.tsv')
 PATH_BAC120_MSA = join(DIR_ALIGN, '{prefix}.bac120.msa.fasta')
-PATH_AR122_MSA = join(DIR_ALIGN, '{prefix}.ar122.msa.fasta')
+PATH_AR53_MSA = join(DIR_ALIGN, '{prefix}.ar53.msa.fasta')
 PATH_BAC120_USER_MSA = join(DIR_ALIGN, '{prefix}.bac120.user_msa.fasta')
-PATH_AR122_USER_MSA = join(DIR_ALIGN, '{prefix}.ar122.user_msa.fasta')
+PATH_AR53_USER_MSA = join(DIR_ALIGN, '{prefix}.ar53.user_msa.fasta')
 PATH_BAC120_MARKER_INFO = join(DIR_ALIGN_INTERMEDIATE, '{prefix}.bac120.marker_info.tsv')
-PATH_AR122_MARKER_INFO = join(DIR_ALIGN_INTERMEDIATE, '{prefix}.ar122.marker_info.tsv')
+PATH_AR53_MARKER_INFO = join(DIR_ALIGN_INTERMEDIATE, '{prefix}.ar53.marker_info.tsv')
 DIR_ALIGN_MARKERS = join(DIR_ALIGN_INTERMEDIATE, 'markers')
 
 # Command: classify
 DIR_CLASSIFY = 'classify'
 PATH_BAC120_TREE_FILE = join(DIR_CLASSIFY, '{prefix}.bac120.classify.tree')
-PATH_AR122_TREE_FILE = join(DIR_CLASSIFY, '{prefix}.ar122.classify.tree')
+PATH_AR53_TREE_FILE = join(DIR_CLASSIFY, '{prefix}.ar53.classify.tree')
 PATH_BAC120_SUMMARY_OUT = join(DIR_CLASSIFY, '{prefix}.bac120.summary.tsv')
-PATH_AR122_SUMMARY_OUT = join(DIR_CLASSIFY, '{prefix}.ar122.summary.tsv')
+PATH_AR53_SUMMARY_OUT = join(DIR_CLASSIFY, '{prefix}.ar53.summary.tsv')
 PATH_HIGH_BAC120_TREE_FILE = join(DIR_CLASSIFY, '{prefix}.high.bac120.classify.tree')
 PATH_LOW_BAC120_TREE_FILE = join(DIR_CLASSIFY, '{prefix}.bac120.classify.tree.{iter}.tree')
 PATH_BAC120_CONFLICT = join(DIR_CLASSIFY, '{prefix}.bac120.conflict.tsv')
+PATH_AR53_DISAPPEARING_GENOMES = join(DIR_CLASSIFY, '{prefix}.ar53.disappearing_genomes.tsv')
+PATH_BAC120_DISAPPEARING_GENOMES = join(DIR_CLASSIFY, '{prefix}.bac120.disappearing_genomes.tsv')
 
 DIR_CLASSIFY_INTERMEDIATE = join(DIR_CLASSIFY, 'intermediate_results')
 PATH_BAC120_RED_DICT = join(DIR_CLASSIFY_INTERMEDIATE, '{prefix}.bac120.red_dictionary.tsv')
-PATH_AR122_RED_DICT = join(DIR_CLASSIFY_INTERMEDIATE, '{prefix}.ar122.red_dictionary.tsv')
+PATH_AR53_RED_DICT = join(DIR_CLASSIFY_INTERMEDIATE, '{prefix}.ar53.red_dictionary.tsv')
 PATH_BAC120_PPLACER_CLASS = join(DIR_CLASSIFY_INTERMEDIATE, '{prefix}.bac120.classification_pplacer.tsv')
+PATH_AR53_PPLACER_CLASS = join(DIR_CLASSIFY_INTERMEDIATE, '{prefix}.ar53.classification_pplacer.tsv')
 PATH_BAC120_HIGH_PPLACER_CLASS = join(DIR_CLASSIFY_INTERMEDIATE, '{prefix}.bac120.high.classification_pplacer.tsv')
 PATH_BAC120_LOW_PPLACER_CLASS = join(DIR_CLASSIFY_INTERMEDIATE, '{prefix}.bac120.low.classification_pplacer_tree_{iter}.tsv')
+PATH_BAC120_TREE_MAPPING = join(DIR_CLASSIFY_INTERMEDIATE, '{prefix}.bac120.tree.mapping.tsv')
+
 
 
-PATH_AR122_PPLACER_CLASS = join(DIR_CLASSIFY_INTERMEDIATE, '{prefix}.ar122.classification_pplacer.tsv')
 
 DIR_PPLACER = join(DIR_CLASSIFY_INTERMEDIATE, 'pplacer')
 PATH_BAC120_PPLACER_OUT = join(DIR_PPLACER, 'pplacer.bac120.out')
-PATH_AR122_PPLACER_OUT = join(DIR_PPLACER, 'pplacer.ar122.out')
+PATH_AR53_PPLACER_OUT = join(DIR_PPLACER, 'pplacer.ar53.out')
 PATH_BAC120_PPLACER_JSON = join(DIR_PPLACER, 'pplacer.bac120.json')
-PATH_AR122_PPLACER_JSON = join(DIR_PPLACER, 'pplacer.ar122.json')
+PATH_AR53_PPLACER_JSON = join(DIR_PPLACER, 'pplacer.ar53.json')
 
 # SPLIT TREE
 PATH_HIGH_BAC120_PPLACER_OUT = join(DIR_PPLACER, 'pplacer.high.bac120.out')
@@ -80,11 +84,11 @@
 PATH_FASTTREE_LOG = join(DIR_INFER_INTERMEDIATE, '{prefix}.fasttree.log')
 
 PATH_BAC120_UNROOTED_TREE = join(DIR_INFER_INTERMEDIATE, '{prefix}.bac120.unrooted.tree')
-PATH_AR122_UNROOTED_TREE = join(DIR_INFER_INTERMEDIATE, '{prefix}.ar122.unrooted.tree')
+PATH_AR53_UNROOTED_TREE = join(DIR_INFER_INTERMEDIATE, '{prefix}.ar53.unrooted.tree')
 PATH_BAC120_ROOTED_TREE = join(DIR_INFER_INTERMEDIATE, '{prefix}.bac120.rooted.tree')
-PATH_AR122_ROOTED_TREE = join(DIR_INFER_INTERMEDIATE, '{prefix}.ar122.rooted.tree')
+PATH_AR53_ROOTED_TREE = join(DIR_INFER_INTERMEDIATE, '{prefix}.ar53.rooted.tree')
 PATH_BAC120_DECORATED_TREE = join(DIR_INFER, '{prefix}.bac120.decorated.tree')
-PATH_AR122_DECORATED_TREE = join(DIR_INFER, '{prefix}.ar122.decorated.tree')
+PATH_AR53_DECORATED_TREE = join(DIR_INFER, '{prefix}.ar53.decorated.tree')
 
 # Command: ani_rep
 DIR_ANI_REP_INT = join('intermediate_results')
diff --git a/gtdbtk/exceptions.py b/gtdbtk/exceptions.py
index beaaeaf1..d20eb33c 100644
--- a/gtdbtk/exceptions.py
+++ b/gtdbtk/exceptions.py
@@ -59,7 +59,7 @@ def __init__(self, message=''):
 
 
 class GenomeMarkerSetUnknown(GTDBTkException):
-    """ Thrown when the genome marker set is unknown (i.e. not ar122, or bac120). """
+    """ Thrown when the genome marker set is unknown (i.e. not ar53, or bac120). """
 
     def __init__(self, message=''):
         GTDBTkException.__init__(self, message)
diff --git a/gtdbtk/external/fasttree.py b/gtdbtk/external/fasttree.py
index cd804507..29b952df 100644
--- a/gtdbtk/external/fasttree.py
+++ b/gtdbtk/external/fasttree.py
@@ -15,9 +15,12 @@
 #                                                                             #
 ###############################################################################
 
+import gzip
 import logging
 import os
+import shutil
 import subprocess
+import tempfile
 
 from gtdbtk.biolib_lite.common import make_sure_path_exists
 from gtdbtk.biolib_lite.execute import check_dependencies
@@ -103,16 +106,28 @@ def run(self, output_tree, tree_log, fasttree_log, prot_model, no_support, gamma
 
         args.append('-log')
         args.append(tree_log)
-        args.append(msa_file)
 
         self.logger.info('Inferring FastTree ({}) using a maximum of {} CPUs.'.format(
             ', '.join(model_out), cpus))
 
-        with open(output_tree, 'w') as f_out_tree:
-            with open(fasttree_log, 'w') as f_out_err:
-                proc = subprocess.Popen(
-                    args, stdout=f_out_tree, stderr=f_out_err, env=env)
-                proc.communicate()
+        # Use a temporary directory if the input file is gzipped
+        with tempfile.TemporaryDirectory(prefix='gtdbtk_') as tmp_dir:
+
+            # Uncompress the archive if it's compressed
+            if msa_file.endswith('.gz'):
+                msa_path = os.path.join(tmp_dir, os.path.basename(msa_file[0:-3]))
+                with gzip.open(msa_file, 'rb') as f_in:
+                    with open(msa_path, 'wb') as f_out:
+                        shutil.copyfileobj(f_in, f_out)
+            else:
+                msa_path = msa_file
+            args.append(msa_path)
+
+            with open(output_tree, 'w') as f_out_tree:
+                with open(fasttree_log, 'w') as f_out_err:
+                    proc = subprocess.Popen(
+                        args, stdout=f_out_tree, stderr=f_out_err, env=env)
+                    proc.communicate()
 
         # Validate results
         if proc.returncode != 0:
diff --git a/gtdbtk/external/hmm_aligner.py b/gtdbtk/external/hmm_aligner.py
index c17f6a21..d3e91b51 100644
--- a/gtdbtk/external/hmm_aligner.py
+++ b/gtdbtk/external/hmm_aligner.py
@@ -24,7 +24,7 @@
 
 from gtdbtk.biolib_lite.execute import check_dependencies
 from gtdbtk.exceptions import GTDBTkException
-from gtdbtk.io.marker.copy_number import CopyNumberFileAR122, CopyNumberFileBAC120
+from gtdbtk.io.marker.copy_number import CopyNumberFileAR53, CopyNumberFileBAC120
 from gtdbtk.io.marker.tophit import TopHitPfamFile, TopHitTigrFile
 from gtdbtk.tools import tqdm_log
 
@@ -40,7 +40,7 @@ def __init__(self,
                  pfam_hmm_dir,
                  tigrfam_hmm_dir,
                  bac120_markers,
-                 ar122_markers):
+                 ar53_markers):
         """Initialization."""
 
         check_dependencies(['hmmalign'])
@@ -55,14 +55,14 @@ def __init__(self,
         self.tigrfam_hmm_dir = tigrfam_hmm_dir
 
         self.bac120_markers = bac120_markers
-        self.ar122_markers = ar122_markers
+        self.ar53_markers = ar53_markers
 
         self.marker_path_prefix = {"PFAM": os.path.join(self.pfam_hmm_dir,
                                                         'individual_hmms'),
                                    "TIGRFAM": os.path.join(os.path.dirname(self.tigrfam_hmm_dir),
                                                            'individual_hmms')}
 
-        self.ar122_marker_sizes = None
+        self.ar53_marker_sizes = None
         self.bac120_marker_sizes = None
 
         self.version = self.get_version()
@@ -85,15 +85,15 @@ def get_version():
             return "(version unavailable)"
 
     def _get_hmm_sizes(self):
-        ar122, bac120 = dict(), dict()
-        for marker_d, out_d in ((self.ar122_markers, ar122),
+        ar53, bac120 = dict(), dict()
+        for marker_d, out_d in ((self.ar53_markers, ar53),
                                 (self.bac120_markers, bac120)):
             for marker_type in ('PFAM', 'TIGRFAM'):
                 for marker_name in marker_d[marker_type]:
                     marker_path = os.path.join(self.marker_path_prefix[marker_type], marker_name)
                     marker_name_strip = marker_name.replace('.HMM', '').replace('.hmm', '')
                     out_d[marker_name_strip] = self._get_hmm_size(marker_path)
-        self.ar122_marker_sizes = ar122
+        self.ar53_marker_sizes = ar53
         self.bac120_marker_sizes = bac120
         return
 
@@ -105,7 +105,7 @@ def align_marker_set(self, db_genome_ids, marker_set_id):
         db_genome_ids : dict
             A dictionary containing the genome ids and aa paths to process.
         marker_set_id : str
-            The marker set of these genomes (bac120/ar122).
+            The marker set of these genomes (bac120/ar53).
 
         Returns
         -------
@@ -211,9 +211,9 @@ def _run_multi_align(self, db_genome_id, path, marker_set_id):
         if marker_set_id == 'bac120':
             copy_number_file = CopyNumberFileBAC120('/dev/null', None)
             marker_size_d = self.bac120_marker_sizes
-        elif marker_set_id == 'ar122':
-            copy_number_file = CopyNumberFileAR122('/dev/null', None)
-            marker_size_d = self.ar122_marker_sizes
+        elif marker_set_id == 'ar53':
+            copy_number_file = CopyNumberFileAR53('/dev/null', None)
+            marker_size_d = self.ar53_marker_sizes
         else:
             raise GTDBTkException('Unknown marker set.')
 
@@ -231,12 +231,12 @@ def _run_multi_align(self, db_genome_id, path, marker_set_id):
                                              os.path.join(
                     marker_paths[db_marker], marker)
                     for marker in self.bac120_markers[db_marker]})
-        elif marker_set_id == "ar122":
-            for db_marker in sorted(self.ar122_markers):
+        elif marker_set_id == "ar53":
+            for db_marker in sorted(self.ar53_markers):
                 marker_dict_original.update({marker.replace(".HMM", "").replace(".hmm", ""):
                                              os.path.join(
                     marker_paths[db_marker], marker)
-                    for marker in self.ar122_markers[db_marker]})
+                    for marker in self.ar53_markers[db_marker]})
         elif marker_set_id == "rps23":
             for db_marker in sorted(self.rps23_markers):
                 marker_dict_original.update({marker.replace(".HMM", "").replace(".hmm", ""):
diff --git a/gtdbtk/infer_ranks.py b/gtdbtk/infer_ranks.py
index 415a1b8d..7464ee29 100644
--- a/gtdbtk/infer_ranks.py
+++ b/gtdbtk/infer_ranks.py
@@ -25,7 +25,7 @@
                                   RED_DIST_BAC_DICT,
                                   RED_DIST_ARC_DICT,
                                   MRCA_RED_BAC120,
-                                  MRCA_RED_AR122,
+                                  MRCA_RED_AR53,
                                   RED_INTERVAL)
 from gtdbtk.exceptions import GTDBTkExit
 from gtdbtk.relative_distance import RelativeDistance
@@ -102,7 +102,7 @@ def _find_ingroup_red(self, ingroup_node, ingroup_domain, tree):
 
         red_file = MRCA_RED_BAC120
         if ingroup_domain == 'd__Archaea':
-            red_file = MRCA_RED_AR122
+            red_file = MRCA_RED_AR53
 
         # create map from leave labels to tree nodes
         leaf_node_map = {}
diff --git a/gtdbtk/io/classify_summary.py b/gtdbtk/io/classify_summary.py
index 87d3c150..d373f3d6 100644
--- a/gtdbtk/io/classify_summary.py
+++ b/gtdbtk/io/classify_summary.py
@@ -18,7 +18,7 @@
 import logging
 import os
 
-from gtdbtk.config.output import PATH_AR122_SUMMARY_OUT, PATH_BAC120_SUMMARY_OUT
+from gtdbtk.config.output import PATH_AR53_SUMMARY_OUT, PATH_BAC120_SUMMARY_OUT
 from gtdbtk.exceptions import GTDBTkExit
 
 
@@ -146,12 +146,12 @@ def read(self):
                 self.add_row(row)
 
 
-class ClassifySummaryFileAR122(ClassifySummaryFile):
-    """Store classify summary information for AR122 markers."""
+class ClassifySummaryFileAR53(ClassifySummaryFile):
+    """Store classify summary information for AR53 markers."""
 
     def __init__(self, out_dir: str, prefix: str):
-        path = os.path.join(out_dir, PATH_AR122_SUMMARY_OUT.format(prefix=prefix))
-        super().__init__(path, 'ar122')
+        path = os.path.join(out_dir, PATH_AR53_SUMMARY_OUT.format(prefix=prefix))
+        super().__init__(path, 'ar53')
 
 
 class ClassifySummaryFileBAC120(ClassifySummaryFile):
@@ -160,3 +160,5 @@ class ClassifySummaryFileBAC120(ClassifySummaryFile):
     def __init__(self, out_dir: str, prefix: str):
         path = os.path.join(out_dir, PATH_BAC120_SUMMARY_OUT.format(prefix=prefix))
         super().__init__(path, 'bac120')
+
+
diff --git a/gtdbtk/io/marker/copy_number.py b/gtdbtk/io/marker/copy_number.py
index b2396918..7eb8d131 100644
--- a/gtdbtk/io/marker/copy_number.py
+++ b/gtdbtk/io/marker/copy_number.py
@@ -21,8 +21,8 @@
 
 from gtdbtk.biolib_lite.common import make_sure_path_exists
 from gtdbtk.biolib_lite.seq_io import read_fasta
-from gtdbtk.config.config import BAC120_MARKERS, AR122_MARKERS
-from gtdbtk.config.output import PATH_BAC120_MARKER_SUMMARY, PATH_AR122_MARKER_SUMMARY
+from gtdbtk.config.config import BAC120_MARKERS, AR53_MARKERS
+from gtdbtk.config.output import PATH_BAC120_MARKER_SUMMARY, PATH_AR53_MARKER_SUMMARY
 from gtdbtk.exceptions import GTDBTkExit
 from gtdbtk.io.marker.tophit import TopHitPfamFile, TopHitTigrFile, Hit
 
@@ -154,12 +154,12 @@ def read(self):
                     raise GTDBTkExit(f'The marker file is inconsistent: {self.path}')
 
 
-class CopyNumberFileAR122(CopyNumberFile):
-    """Store hmm copy number information for AR122 markers."""
+class CopyNumberFileAR53(CopyNumberFile):
+    """Store hmm copy number information for AR53 markers."""
 
     def __init__(self, out_dir: str, prefix: str):
-        path = os.path.join(out_dir, PATH_AR122_MARKER_SUMMARY.format(prefix=prefix))
-        super().__init__(path, 'ar122', AR122_MARKERS)
+        path = os.path.join(out_dir, PATH_AR53_MARKER_SUMMARY.format(prefix=prefix))
+        super().__init__(path, 'ar53', AR53_MARKERS)
 
 
 class CopyNumberFileBAC120(CopyNumberFile):
diff --git a/gtdbtk/io/marker_info.py b/gtdbtk/io/marker_info.py
index f636873f..b5e07809 100644
--- a/gtdbtk/io/marker_info.py
+++ b/gtdbtk/io/marker_info.py
@@ -18,8 +18,8 @@
 import os
 
 from gtdbtk.biolib_lite.common import make_sure_path_exists
-from gtdbtk.config.config import AR122_MARKERS, BAC120_MARKERS, TIGRFAM_HMMS, PFAM_HMM_DIR
-from gtdbtk.config.output import PATH_AR122_MARKER_INFO, PATH_BAC120_MARKER_INFO
+from gtdbtk.config.config import AR53_MARKERS, BAC120_MARKERS, TIGRFAM_HMMS, PFAM_HMM_DIR
+from gtdbtk.config.output import PATH_AR53_MARKER_INFO, PATH_BAC120_MARKER_INFO
 
 
 class MarkerInfoFile(object):
@@ -66,12 +66,12 @@ def write(self):
                 fh.write('\t'.join(row) + '\n')
 
 
-class MarkerInfoFileAR122(MarkerInfoFile):
-    """Marker information for the AR122 marker set."""
+class MarkerInfoFileAR53(MarkerInfoFile):
+    """Marker information for the AR53 marker set."""
 
     def __init__(self, out_dir: str, prefix: str):
-        path = os.path.join(out_dir, PATH_AR122_MARKER_INFO.format(prefix=prefix))
-        super().__init__(path, AR122_MARKERS)
+        path = os.path.join(out_dir, PATH_AR53_MARKER_INFO.format(prefix=prefix))
+        super().__init__(path, AR53_MARKERS)
 
 
 class MarkerInfoFileBAC120(MarkerInfoFile):
diff --git a/gtdbtk/io/missing_genomes.py b/gtdbtk/io/missing_genomes.py
new file mode 100644
index 00000000..869fde53
--- /dev/null
+++ b/gtdbtk/io/missing_genomes.py
@@ -0,0 +1,63 @@
+###############################################################################
+#                                                                             #
+#    This program is free software: you can redistribute it and/or modify     #
+#    it under the terms of the GNU General Public License as published by     #
+#    the Free Software Foundation, either version 3 of the License, or        #
+#    (at your option) any later version.                                      #
+#                                                                             #
+#    This program is distributed in the hope that it will be useful,          #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of           #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
+#    GNU General Public License for more details.                             #
+#                                                                             #
+#    You should have received a copy of the GNU General Public License        #
+#    along with this program. If not, see <http://www.gnu.org/licenses/>.     #
+#                                                                             #
+###############################################################################
+
+import os
+from typing import Dict
+
+from gtdbtk.biolib_lite.common import make_sure_path_exists
+from gtdbtk.config.output import PATH_AR53_DISAPPEARING_GENOMES, PATH_BAC120_DISAPPEARING_GENOMES
+from gtdbtk.exceptions import GTDBTkExit
+
+
+class DisappearingGenomesFile(object):
+    """Store the GTDB-Tk RED dictionary."""
+
+    def __init__(self, path: str,domain: str):
+        self.path: str = path
+        self.domain: str = domain
+        self.data: Dict[str, str] = dict()
+        self.file_name: str = os.path.basename(path)
+
+    def add_genome(self, gid: str, tree_index: str):
+        """PlAdds the pplacer classification of a given genome."""
+        if gid in self.data:
+            raise GTDBTkExit(f'Warning! Attempting to add duplicate genome: {gid}')
+        self.data[gid] = tree_index
+
+    def write(self):
+        """Write the file to disk, note that domain is omitted."""
+        make_sure_path_exists(os.path.dirname(self.path))
+        with open(self.path, 'w') as fh:
+            fh.write(f'genome_id\tdomain\ttree_index\n')
+            for seqid, infos in self.data.items():
+                fh.write(f'{seqid}\t{self.domain}\t{infos}\n')
+
+
+class DisappearingGenomesFileAR53(DisappearingGenomesFile):
+    """Store the RED dictionary for the AR53 marker set."""
+
+    def __init__(self, out_dir: str, prefix: str):
+        path = os.path.join(out_dir, PATH_AR53_DISAPPEARING_GENOMES.format(prefix=prefix))
+        super().__init__(path,'archaea')
+
+
+class DisappearingGenomesFileBAC120(DisappearingGenomesFile):
+    """Store the RED dictionary for the BAC120 marker set."""
+
+    def __init__(self, out_dir: str, prefix: str):
+        path = os.path.join(out_dir, PATH_BAC120_DISAPPEARING_GENOMES.format(prefix=prefix))
+        super().__init__(path,'bacteria')
diff --git a/gtdbtk/io/pplacer_classification.py b/gtdbtk/io/pplacer_classification.py
index 997b02ef..4deae677 100644
--- a/gtdbtk/io/pplacer_classification.py
+++ b/gtdbtk/io/pplacer_classification.py
@@ -19,7 +19,8 @@
 from typing import Dict
 
 from gtdbtk.biolib_lite.common import make_sure_path_exists
-from gtdbtk.config.output import PATH_AR122_PPLACER_CLASS, PATH_BAC120_PPLACER_CLASS
+from gtdbtk.config.output import PATH_AR53_PPLACER_CLASS, PATH_BAC120_PPLACER_CLASS, PATH_BAC120_HIGH_PPLACER_CLASS, \
+    PATH_BAC120_LOW_PPLACER_CLASS
 from gtdbtk.exceptions import GTDBTkExit
 
 
@@ -30,6 +31,7 @@ def __init__(self, path: str):
         self.path: str = path
         self.data: Dict[str, str] = dict()
 
+
     def add_genome(self, gid: str, tax_str: str):
         """Adds the pplacer classification of a given genome."""
         if gid in self.data:
@@ -39,16 +41,17 @@ def add_genome(self, gid: str, tax_str: str):
     def write(self):
         """Write the file to disk."""
         make_sure_path_exists(os.path.dirname(self.path))
-        with open(self.path, 'w') as fh:
-            for gid, tax_str in sorted(self.data.items()):
-                fh.write(f'{gid}\t{tax_str}\n')
+        if len(self.data) > 0 :
+            with open(self.path, 'w') as fh:
+                for gid, tax_str in sorted(self.data.items()):
+                    fh.write(f'{gid}\t{tax_str}\n')
 
 
-class PplacerClassifyFileAR122(PplacerClassifyFile):
-    """Store the pplacer classifications for the AR122 marker set."""
+class PplacerClassifyFileAR53(PplacerClassifyFile):
+    """Store the pplacer classifications for the AR53 marker set."""
 
     def __init__(self, out_dir: str, prefix: str):
-        path = os.path.join(out_dir, PATH_AR122_PPLACER_CLASS.format(prefix=prefix))
+        path = os.path.join(out_dir, PATH_AR53_PPLACER_CLASS.format(prefix=prefix))
         super().__init__(path)
 
 
@@ -58,3 +61,67 @@ class PplacerClassifyFileBAC120(PplacerClassifyFile):
     def __init__(self, out_dir: str, prefix: str):
         path = os.path.join(out_dir, PATH_BAC120_PPLACER_CLASS.format(prefix=prefix))
         super().__init__(path)
+
+class PplacerLowClassifyFileBAC120(PplacerClassifyFile):
+    """Store the pplacer classifications for the BAC120 marker set."""
+
+    def __init__(self, out_dir: str, prefix: str,iter:str):
+        path = os.path.join(out_dir, PATH_BAC120_LOW_PPLACER_CLASS.format(prefix=prefix,iter=iter))
+        super().__init__(path)
+
+
+class PplacerHighClassifyRow(object):
+    """Initialise the row, default all of the values to None."""
+
+    def __init__(self):
+        self.gid = None
+        self.gtdb_taxonomy_red = None
+        self.gtdb_taxonomy_terminal = None
+        self.pplacer_taxonomy = None
+        self.is_terminal = None
+        self.red = None
+
+
+class PplacerHighClassifyFile(object):
+    """Store the pplacer classifications."""
+
+    def __init__(self,out_dir: str,prefix: str):
+        self.path = os.path.join(out_dir, PATH_BAC120_HIGH_PPLACER_CLASS.format(prefix=prefix))
+        self.rows = dict()  # keyed by user_genome
+        self.none_value = 'N/A'
+
+    def add_row(self, row: PplacerHighClassifyRow):
+        if row.gid in self.rows:
+            raise GTDBTkExit(f'Attempting to add duplicate row: {row.gid}')
+        self.rows[row.gid] = row
+
+    @staticmethod
+    def get_col_order(row: PplacerHighClassifyRow = None):
+        """Return the column order that will be written. If a row is provided
+        then format the row in that specific order."""
+        if row is None:
+            row = PplacerHighClassifyRow()
+        mapping = [('user_genome', row.gid),
+                   ('gtdb_taxonomy_red', row.gtdb_taxonomy_red),
+                   ('gtdb_taxonomy_terminal', row.gtdb_taxonomy_terminal),
+                   ('pplacer_taxonomy', row.pplacer_taxonomy),
+                   ('is_terminal', row.is_terminal),
+                   ('red', row.red)]
+        cols, data = list(), list()
+        for col_name, col_val in mapping:
+            cols.append(col_name)
+            data.append(col_val)
+        return cols, data
+
+
+    def write(self):
+        """Write the file to disk."""
+        make_sure_path_exists(os.path.dirname(self.path))
+        cols = ['gid','gtdb_taxonomy','pplacer_taxonomy','is_terminal','red']
+        with open(self.path, 'w') as fh:
+            fh.write('\t'.join(self.get_col_order()[0]) + '\n')
+            for gid, row in sorted(self.rows.items()):
+                buf = list()
+                for data in self.get_col_order(row)[1]:
+                    buf.append(self.none_value if data is None else str(data))
+                fh.write('\t'.join(buf) + '\n')
diff --git a/gtdbtk/io/red_dict.py b/gtdbtk/io/red_dict.py
index 03bec75b..989b64ec 100644
--- a/gtdbtk/io/red_dict.py
+++ b/gtdbtk/io/red_dict.py
@@ -20,7 +20,7 @@
 
 from gtdbtk.biolib_lite.common import make_sure_path_exists
 from gtdbtk.config.config import RED_DIST_ARC_DICT, RED_DIST_BAC_DICT
-from gtdbtk.config.output import PATH_AR122_RED_DICT, PATH_BAC120_RED_DICT
+from gtdbtk.config.output import PATH_AR53_RED_DICT, PATH_BAC120_RED_DICT
 
 
 class REDDictFile(object):
@@ -41,11 +41,11 @@ def write(self):
             fh.write(f'Genus\t{self.data["g__"]}\n')
 
 
-class REDDictFileAR122(REDDictFile):
-    """Store the RED dictionary for the AR122 marker set."""
+class REDDictFileAR53(REDDictFile):
+    """Store the RED dictionary for the AR53 marker set."""
 
     def __init__(self, out_dir: str, prefix: str):
-        path = os.path.join(out_dir, PATH_AR122_RED_DICT.format(prefix=prefix))
+        path = os.path.join(out_dir, PATH_AR53_RED_DICT.format(prefix=prefix))
         super().__init__(path, RED_DIST_ARC_DICT)
 
 
diff --git a/gtdbtk/io/tree_mapping.py b/gtdbtk/io/tree_mapping.py
new file mode 100644
index 00000000..8880ccbe
--- /dev/null
+++ b/gtdbtk/io/tree_mapping.py
@@ -0,0 +1,91 @@
+###############################################################################
+#                                                                             #
+#    This program is free software: you can redistribute it and/or modify     #
+#    it under the terms of the GNU General Public License as published by     #
+#    the Free Software Foundation, either version 3 of the License, or        #
+#    (at your option) any later version.                                      #
+#                                                                             #
+#    This program is distributed in the hope that it will be useful,          #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of           #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
+#    GNU General Public License for more details.                             #
+#                                                                             #
+#    You should have received a copy of the GNU General Public License        #
+#    along with this program. If not, see <http://www.gnu.org/licenses/>.     #
+#                                                                             #
+###############################################################################
+
+import logging
+import os
+
+from gtdbtk.config.output import PATH_BAC120_TREE_MAPPING
+from gtdbtk.exceptions import GTDBTkExit
+
+
+class GenomeMappingFileRow(object):
+    """A row contained within the GenomeMappingFile object."""
+
+    def __init__(self):
+        self.gid = None
+        self.ani_classification = None
+        self.mapped_tree = None
+
+class GenomeMappingFile(object):
+    """Store the GTDB-Tk classify summary output."""
+
+    def __init__(self, out_dir: str,prefix: str):
+        self.logger = logging.getLogger('timestamp')
+        self.path = os.path.join(out_dir, PATH_BAC120_TREE_MAPPING.format(prefix=prefix))
+        self.rows = dict()  # keyed by user_genome
+        self.none_value = 'N/A'
+
+    @staticmethod
+    def get_col_order(row: GenomeMappingFileRow = None):
+        """Return the column order that will be written. If a row is provided
+        then format the row in that specific order."""
+        if row is None:
+            row = GenomeMappingFileRow()
+        mapping = [('user_genome', row.gid),
+                   ('is_ani_classification', row.ani_classification),
+                   ('species_tree_mapped', row.mapped_tree)]
+        cols, data = list(), list()
+        for col_name, col_val in mapping:
+            cols.append(col_name)
+            data.append(col_val)
+        return cols, data
+
+    def add_row(self, row: GenomeMappingFileRow):
+        if row.gid in self.rows:
+            raise GTDBTkExit(f'Attempting to add duplicate row: {row.gid}')
+        self.rows[row.gid] = row
+
+    def write(self):
+        """Writes the summary file to disk. None will be replaced with N/A"""
+        with open(self.path, 'w') as fh:
+            fh.write('\t'.join(self.get_col_order()[0]) + '\n')
+            for gid, row in sorted(self.rows.items()):
+                buf = list()
+                for data in self.get_col_order(row)[1]:
+                    buf.append(self.none_value if data is None else str(data))
+                fh.write('\t'.join(buf) + '\n')
+
+    def read(self):
+        """Read the summary file from disk."""
+        if not os.path.isfile(self.path):
+            raise GTDBTkExit(f'Error, classify tree mappings file not found: {self.path}')
+        with open(self.path) as fh:
+
+            # Load and verify the columns match the expected order.
+            cols_exp, _ = self.get_col_order()
+            cols_cur = fh.readline().strip().split('\t')
+            if cols_exp != cols_cur:
+                raise GTDBTkExit(f'The classify tree mappings columns are inconsistent: {cols_cur}')
+
+            # Process the data.
+            for line in fh.readlines():
+                data = line.strip().split('\t')
+                row = GenomeMappingFileRow()
+                row.gid = data[0]
+                row.ani_classification = data[1]
+                row.mapped_tree = data[2]
+                self.add_row(row)
\ No newline at end of file
diff --git a/gtdbtk/main.py b/gtdbtk/main.py
index ee1dab70..ecc788af 100644
--- a/gtdbtk/main.py
+++ b/gtdbtk/main.py
@@ -41,7 +41,7 @@
 from gtdbtk.external.fasttree import FastTree
 from gtdbtk.infer_ranks import InferRanks
 from gtdbtk.io.batchfile import Batchfile
-from gtdbtk.io.classify_summary import ClassifySummaryFileAR122
+from gtdbtk.io.classify_summary import ClassifySummaryFileAR53
 from gtdbtk.markers import Markers
 from gtdbtk.misc import Misc
 from gtdbtk.model.enum import Domain
@@ -273,6 +273,7 @@ def identify(self, options):
                          options.out_dir,
                          options.prefix,
                          options.force,
+                         options.genes,
                          options.write_single_copy_genes)
 
         self.logger.info('Done.')
@@ -395,7 +396,7 @@ def run_test(self, options):
             shutil.copytree(input_dir, genome_test_dir)
 
             args = ['gtdbtk', 'classify_wf', '--genome_dir', genome_test_dir,
-                    '--out_dir', output_dir, '--cpus', str(options.cpus)]
+                    '--out_dir', output_dir, '--cpus', str(options.cpus), '-f']
             self.logger.info('Command: {}'.format(' '.join(args)))
 
             # Pipe the output and write to disk.
@@ -414,7 +415,7 @@ def run_test(self, options):
                 proc.wait()
                 exit_code = proc.returncode
 
-            summary_fh = ClassifySummaryFileAR122(output_dir, 'gtdbtk')
+            summary_fh = ClassifySummaryFileAR53(output_dir, 'gtdbtk')
 
             if exit_code != 0:
                 self.logger.error('The test returned a non-zero exit code.')
@@ -460,9 +461,13 @@ def classify(self, options):
                      prefix=options.prefix,
                      scratch_dir=options.scratch_dir,
                      debugopt=options.debug,
-                     splittreeopt=options.split_tree,
+                     fulltreeopt=options.full_tree,
                      recalculate_red=False)
 
+        self.logger.info('Note that Tk classification mode is insufficient for publication of new taxonomic '
+                         'designations. New designations should be based on one or more de novo trees, an '
+                         'example of which can be produced by Tk in de novo mode.')
+
         self.logger.info('Done.')
 
     def trim_msa(self, options):
@@ -566,14 +571,14 @@ def decorate(self, options):
                           os.path.join(options.out_dir,
                                        os.path.basename(
                                            PATH_BAC120_DECORATED_TREE.format(prefix=options.prefix) + '-table')))
-            elif options.suffix == 'ar122':
-                symlink_f(PATH_AR122_DECORATED_TREE.format(prefix=options.prefix),
+            elif options.suffix == 'ar53':
+                symlink_f(PATH_AR53_DECORATED_TREE.format(prefix=options.prefix),
                           os.path.join(options.out_dir,
-                                       os.path.basename(PATH_AR122_DECORATED_TREE.format(prefix=options.prefix))))
-                symlink_f(PATH_AR122_DECORATED_TREE.format(prefix=options.prefix) + '-table',
+                                       os.path.basename(PATH_AR53_DECORATED_TREE.format(prefix=options.prefix))))
+                symlink_f(PATH_AR53_DECORATED_TREE.format(prefix=options.prefix) + '-table',
                           os.path.join(options.out_dir,
                                        os.path.basename(
-                                           PATH_AR122_DECORATED_TREE.format(prefix=options.prefix) + '-table')))
+                                           PATH_AR53_DECORATED_TREE.format(prefix=options.prefix) + '-table')))
             else:
                 raise GenomeMarkerSetUnknown(
                     'There was an error determining the marker set.')
@@ -623,6 +628,47 @@ def ani_rep(self, options):
 
         self.logger.info('Done.')
 
+    def convert_to_itol(self, options):
+        """Convert Tree to iTOL format.
+
+        Parameters
+        ----------
+        options : argparse.Namespace
+            The CLI arguments input by the user.
+        """
+        check_file_exists(options.input_tree)
+
+        r = Misc()
+        r.convert_to_itol(options.input_tree, options.output_tree)
+        self.logger.info('Done.')
+
+    def remove_labels(self, options):
+        """Remove labels from tree.
+
+        Parameters
+        ----------
+        options : argparse.Namespace
+            The CLI arguments input by the user.
+        """
+
+        check_file_exists(options.input_tree)
+
+        r = Misc()
+        r.remove_labels(options.input_tree, options.output_tree)
+        self.logger.info('Done.')
+
+    def remove_intermediate_files(self,out_dir,workflow_name):
+        """Remove intermediate files from the output directory.
+        Parameters
+        ----------
+            out_dir : str
+                The output directory.
+        """
+
+        misc = Misc()
+        misc.remove_intermediate_files(out_dir,workflow_name)
+        self.logger.info('Done.')
+
     def parse_options(self, options):
         """Parse user options and call the correct pipeline(s)
 
@@ -664,15 +710,26 @@ def parse_options(self, options):
             if options.bacteria:
                 options.suffix = "bac120"
             else:
-                options.suffix = "ar122"
+                options.suffix = "ar53"
 
             if options.skip_gtdb_refs:
                 if options.suffix == 'bac120':
-                    options.msa_file = os.path.join(
-                        options.out_dir, PATH_BAC120_USER_MSA.format(prefix=options.prefix))
-                elif options.suffix == 'ar122':
-                    options.msa_file = os.path.join(
-                        options.out_dir, PATH_AR122_USER_MSA.format(prefix=options.prefix))
+                    if os.path.isfile(os.path.join(options.out_dir,
+                                                   PATH_BAC120_USER_MSA.format(prefix=options.prefix))):
+                        options.msa_file = os.path.join(options.out_dir,
+                                                     PATH_BAC120_USER_MSA.format(prefix=options.prefix))
+                    else:
+                        options.msa_file = os.path.join(options.out_dir,
+                                                     PATH_BAC120_USER_MSA.format(prefix=options.prefix) + '.gz')
+
+                elif options.suffix == 'ar53':
+                    if os.path.isfile(os.path.join(options.out_dir,
+                                                   PATH_AR53_USER_MSA.format(prefix=options.prefix))):
+                        options.msa_file = os.path.join(options.out_dir,
+                                                     PATH_AR53_USER_MSA.format(prefix=options.prefix))
+                    else:
+                        options.msa_file = os.path.join(options.out_dir,
+                                                     PATH_AR53_USER_MSA.format(prefix=options.prefix) + '.gz')
                 else:
                     self.logger.error(
                         'There was an error determining the marker set.')
@@ -680,11 +737,21 @@ def parse_options(self, options):
                         'Unknown marker set: {}'.format(options.suffix))
             else:
                 if options.suffix == 'bac120':
-                    options.msa_file = os.path.join(
-                        options.out_dir, PATH_BAC120_MSA.format(prefix=options.prefix))
-                elif options.suffix == 'ar122':
-                    options.msa_file = os.path.join(
-                        options.out_dir, PATH_AR122_MSA.format(prefix=options.prefix))
+                    if os.path.isfile(os.path.join(
+                        options.out_dir, PATH_BAC120_MSA.format(prefix=options.prefix))):
+                        options.msa_file = os.path.join(
+                            options.out_dir, PATH_BAC120_MSA.format(prefix=options.prefix))
+                    else:
+                        options.msa_file = os.path.join(
+                            options.out_dir, PATH_BAC120_MSA.format(prefix=options.prefix) + '.gz')
+                elif options.suffix == 'ar53':
+                    if os.path.isfile(os.path.join(
+                        options.out_dir, PATH_AR53_MSA.format(prefix=options.prefix))):
+                        options.msa_file = os.path.join(
+                            options.out_dir, PATH_AR53_MSA.format(prefix=options.prefix))
+                    else:
+                        options.msa_file = os.path.join(
+                            options.out_dir, PATH_AR53_MSA.format(prefix=options.prefix) + '.gz')
                 else:
                     self.logger.error(
                         'There was an error determining the marker set.')
@@ -698,11 +765,11 @@ def parse_options(self, options):
                                                   PATH_BAC120_UNROOTED_TREE.format(prefix=options.prefix))
                 options.output_tree = os.path.join(options.out_dir,
                                                    PATH_BAC120_ROOTED_TREE.format(prefix=options.prefix))
-            elif options.suffix == 'ar122':
+            elif options.suffix == 'ar53':
                 options.input_tree = os.path.join(options.out_dir,
-                                                  PATH_AR122_UNROOTED_TREE.format(prefix=options.prefix))
+                                                  PATH_AR53_UNROOTED_TREE.format(prefix=options.prefix))
                 options.output_tree = os.path.join(options.out_dir,
-                                                   PATH_AR122_ROOTED_TREE.format(prefix=options.prefix))
+                                                   PATH_AR53_ROOTED_TREE.format(prefix=options.prefix))
 
             self.root(options)
 
@@ -711,21 +778,18 @@ def parse_options(self, options):
                                                   PATH_BAC120_ROOTED_TREE.format(prefix=options.prefix))
                 options.output_tree = os.path.join(options.out_dir,
                                                    PATH_BAC120_DECORATED_TREE.format(prefix=options.prefix))
-            elif options.suffix == 'ar122':
+            elif options.suffix == 'ar53':
                 options.input_tree = os.path.join(options.out_dir,
-                                                  PATH_AR122_ROOTED_TREE.format(prefix=options.prefix))
+                                                  PATH_AR53_ROOTED_TREE.format(prefix=options.prefix))
                 options.output_tree = os.path.join(options.out_dir,
-                                                   PATH_AR122_DECORATED_TREE.format(prefix=options.prefix))
+                                                   PATH_AR53_DECORATED_TREE.format(prefix=options.prefix))
 
             self.decorate(options)
 
-        elif options.subparser_name == 'classify_wf':
+            if not options.keep_intermediates:
+                self.remove_intermediate_files(options.out_dir,'de_novo_wf')
 
-            # TODO: Remove this block once the split_tree function is implemented.
-            if hasattr(options, 'split_tree') and options.split_tree:
-                self.logger.warning('The split tree option is not yet '
-                                    ' supported, overriding value to False.')
-            options.split_tree = False
+        elif options.subparser_name == 'classify_wf':
 
             check_dependencies(['prodigal', 'hmmalign', 'pplacer', 'guppy',
                                 'fastANI'])
@@ -750,6 +814,9 @@ def parse_options(self, options):
             self.align(options)
 
             self.classify(options)
+            if not options.keep_intermediates:
+                self.remove_intermediate_files(options.out_dir,'classify_wf')
+
         elif options.subparser_name == 'identify':
             self.identify(options)
         elif options.subparser_name == 'align':
@@ -759,10 +826,10 @@ def parse_options(self, options):
         elif options.subparser_name == 'classify':
 
             # TODO: Remove this block once the split_tree function is implemented.
-            if hasattr(options, 'split_tree') and options.split_tree:
-                self.logger.warning('The split tree option is not yet '
-                                    ' supported, overriding value to False.')
-            options.split_tree = False
+            # if hasattr(options, 'split_tree') and options.split_tree:
+            #     self.logger.warning('The split tree option is not yet '
+            #                         ' supported, overriding value to False.')
+            # options.split_tree = False
 
             # if options.recalculate_red and options.split_tree:
             #     raise GTDBTkExit('--split_tree and --recalculate_red are mutually exclusive.')
@@ -775,6 +842,10 @@ def parse_options(self, options):
             self.infer_ranks(options)
         elif options.subparser_name == 'ani_rep':
             self.ani_rep(options)
+        elif options.subparser_name == 'remove_labels':
+            self.remove_labels(options)
+        elif options.subparser_name == 'convert_to_itol':
+            self.convert_to_itol(options)
         elif options.subparser_name == 'trim_msa':
             self.trim_msa(options)
         elif options.subparser_name == 'export_msa':
diff --git a/gtdbtk/markers.py b/gtdbtk/markers.py
index 8677617e..579e5055 100644
--- a/gtdbtk/markers.py
+++ b/gtdbtk/markers.py
@@ -21,6 +21,7 @@
 from shutil import copy
 from typing import Dict, Tuple, Optional
 
+import gzip
 import numpy as np
 
 import gtdbtk.config.config as Config
@@ -33,9 +34,9 @@
 from gtdbtk.external.pfam_search import PfamSearch
 from gtdbtk.external.prodigal import Prodigal
 from gtdbtk.external.tigrfam_search import TigrfamSearch
-from gtdbtk.io.marker.copy_number import CopyNumberFileAR122, CopyNumberFileBAC120
+from gtdbtk.io.marker.copy_number import CopyNumberFileAR53, CopyNumberFileBAC120
 from gtdbtk.io.marker.tophit import TopHitPfamFile, TopHitTigrFile
-from gtdbtk.io.marker_info import MarkerInfoFileAR122, MarkerInfoFileBAC120
+from gtdbtk.io.marker_info import MarkerInfoFileAR53, MarkerInfoFileBAC120
 from gtdbtk.io.prodigal.tln_table import TlnTableFile
 from gtdbtk.io.prodigal.tln_table_summary import TlnTableSummaryFile
 from gtdbtk.pipeline import align
@@ -57,7 +58,6 @@ def __init__(self, cpus=1, debug=False):
         self.marker_gene_dir = None
         self.failed_genomes = None
 
-
         self.genome_file_suffix = GENOME_FILE_SUFFIX
         self.protein_file_suffix = PROTEIN_FILE_SUFFIX
         self.nt_gene_file_suffix = NT_GENE_FILE_SUFFIX
@@ -78,9 +78,9 @@ def _report_identified_marker_genes(self, gene_dict, outdir, prefix,
                                         write_single_copy_genes):
         """Report statistics for identified marker genes."""
 
-        # Summarise the copy number of each AR122 and BAC120 markers.
+        # Summarise the copy number of each AR53 and BAC120 markers.
         tln_summary_file = TlnTableSummaryFile(outdir, prefix)
-        ar122_copy_number_file = CopyNumberFileAR122(outdir, prefix)
+        ar53_copy_number_file = CopyNumberFileAR53(outdir, prefix)
         bac120_copy_number_file = CopyNumberFileBAC120(outdir, prefix)
 
         # Process each genome.
@@ -92,39 +92,41 @@ def _report_identified_marker_genes(self, gene_dict, outdir, prefix,
             tigr_tophit_file.read()
 
             # Summarise each of the markers for this genome.
-            ar122_copy_number_file.add_genome(db_genome_id, info.get("aa_gene_path"),
-                                              pfam_tophit_file, tigr_tophit_file)
+            ar53_copy_number_file.add_genome(db_genome_id, info.get("aa_gene_path"),
+                                             pfam_tophit_file, tigr_tophit_file)
             bac120_copy_number_file.add_genome(db_genome_id, info.get("aa_gene_path"),
                                                pfam_tophit_file, tigr_tophit_file)
 
             # Write the best translation table to disk for this genome.
-            tln_summary_file.add_genome(db_genome_id, info.get("best_translation_table"))
+            tln_summary_file.add_genome(
+                db_genome_id, info.get("best_translation_table"))
 
         # Write each of the summary files to disk.
-        ar122_copy_number_file.write()
+        ar53_copy_number_file.write()
         bac120_copy_number_file.write()
         tln_summary_file.write()
 
         # Create a symlink to store the summary files in the root.
-        symlink_f(PATH_BAC120_MARKER_SUMMARY.format(prefix=prefix),
-                  os.path.join(outdir, os.path.basename(PATH_BAC120_MARKER_SUMMARY.format(prefix=prefix))))
-        symlink_f(PATH_AR122_MARKER_SUMMARY.format(prefix=prefix),
-                  os.path.join(outdir, os.path.basename(PATH_AR122_MARKER_SUMMARY.format(prefix=prefix))))
-        symlink_f(PATH_TLN_TABLE_SUMMARY.format(prefix=prefix),
-                  os.path.join(outdir, os.path.basename(PATH_TLN_TABLE_SUMMARY.format(prefix=prefix))))
+        # symlink_f(PATH_BAC120_MARKER_SUMMARY.format(prefix=prefix),
+        #           os.path.join(outdir, os.path.basename(PATH_BAC120_MARKER_SUMMARY.format(prefix=prefix))))
+        # symlink_f(PATH_AR53_MARKER_SUMMARY.format(prefix=prefix),
+        #           os.path.join(outdir, os.path.basename(PATH_AR53_MARKER_SUMMARY.format(prefix=prefix))))
+        # symlink_f(PATH_TLN_TABLE_SUMMARY.format(prefix=prefix),
+        #           os.path.join(outdir, os.path.basename(PATH_TLN_TABLE_SUMMARY.format(prefix=prefix))))
         symlink_f(PATH_FAILS.format(prefix=prefix),
                   os.path.join(outdir, os.path.basename(PATH_FAILS.format(prefix=prefix))))
 
-        # Write the single copy AR122/BAC120 FASTA files to disk.
+        # Write the single copy AR53/BAC120 FASTA files to disk.
         if write_single_copy_genes:
             fasta_dir = os.path.join(outdir, DIR_IDENTIFY_FASTA)
-            self.logger.info(f'Writing unaligned single-copy genes to: {fasta_dir}')
+            self.logger.info(
+                f'Writing unaligned single-copy genes to: {fasta_dir}')
 
             # Iterate over each domain.
             marker_doms = list()
-            marker_doms.append((Config.AR122_MARKERS['PFAM'] +
-                                Config.AR122_MARKERS['TIGRFAM'],
-                                ar122_copy_number_file, 'ar122'))
+            marker_doms.append((Config.AR53_MARKERS['PFAM'] +
+                                Config.AR53_MARKERS['TIGRFAM'],
+                                ar53_copy_number_file, 'ar53'))
             marker_doms.append((Config.BAC120_MARKERS['PFAM'] +
                                 Config.BAC120_MARKERS['TIGRFAM'],
                                 bac120_copy_number_file, 'bac120'))
@@ -137,7 +139,8 @@ def _report_identified_marker_genes(self, gene_dict, outdir, prefix,
                 # Iterate over each marker.
                 for marker_name in marker_names:
                     marker_name = marker_name.rstrip(r'\.[HMMhmm]')
-                    marker_path = os.path.join(fasta_d_dir, f'{marker_name}.fa')
+                    marker_path = os.path.join(
+                        fasta_d_dir, f'{marker_name}.fa')
 
                     to_write = list()
                     for genome_id in sorted(gene_dict):
@@ -150,7 +153,7 @@ def _report_identified_marker_genes(self, gene_dict, outdir, prefix,
                         with open(marker_path, 'w') as fh:
                             fh.write('\n'.join(to_write))
 
-    def identify(self, genomes, tln_tables, out_dir, prefix, force, write_single_copy_genes):
+    def identify(self, genomes, tln_tables, out_dir, prefix, force, genes, write_single_copy_genes):
         """Identify marker genes in genomes.
 
         Parameters
@@ -165,8 +168,10 @@ def identify(self, genomes, tln_tables, out_dir, prefix, force, write_single_cop
             Prefix to append to generated files.
         force : bool
             Overwrite any existing files.
+        genes : bool
+            True if the supplied genomes are called genes, False otherwise.
         write_single_copy_genes : bool
-            Write unique AR122/BAC120 marker files to disk.
+            Write unique AR53/BAC120 marker files to disk.
 
         Raises
         ------
@@ -180,19 +185,35 @@ def identify(self, genomes, tln_tables, out_dir, prefix, force, write_single_cop
                          f'{self.cpus} threads.')
 
         self.marker_gene_dir = os.path.join(out_dir, DIR_MARKER_GENE)
-        self.failed_genomes = os.path.join(out_dir, PATH_FAILS.format(prefix=prefix))
-        prodigal = Prodigal(self.cpus,
-                            self.failed_genomes,
-                            self.marker_gene_dir,
-                            self.protein_file_suffix,
-                            self.nt_gene_file_suffix,
-                            self.gff_file_suffix,
-                            force)
-        self.logger.log(Config.LOG_TASK, f'Running Prodigal {prodigal.version} to identify genes.')
-        genome_dictionary = prodigal.run(genomes, tln_tables)
+        self.failed_genomes = os.path.join(
+            out_dir, PATH_FAILS.format(prefix=prefix))
+
+        if not genes:
+            prodigal = Prodigal(self.cpus,
+                                self.failed_genomes,
+                                self.marker_gene_dir,
+                                self.protein_file_suffix,
+                                self.nt_gene_file_suffix,
+                                self.gff_file_suffix,
+                                force)
+            self.logger.log(
+                Config.LOG_TASK, f'Running Prodigal {prodigal.version} to identify genes.')
+            genome_dictionary = prodigal.run(genomes, tln_tables)
+
+        else:
+            self.logger.info(
+                'Using supplied genomes as called genes, skipping Prodigal.')
+            genome_dictionary = dict()
+            for gid, gpath in genomes.items():
+                genome_dictionary[gid] = {'aa_gene_path': gpath,
+                                          'translation_table_path': None,
+                                          'nt_gene_path': None,
+                                          'best_translation_table': 'user_supplied',
+                                          'gff_path': None}
 
         # annotated genes against TIGRFAM and Pfam databases
-        self.logger.log(Config.LOG_TASK, 'Identifying TIGRFAM protein families.')
+        self.logger.log(Config.LOG_TASK,
+                        'Identifying TIGRFAM protein families.')
         gene_files = [genome_dictionary[db_genome_id]['aa_gene_path']
                       for db_genome_id in genome_dictionary.keys()]
         tigr_search = TigrfamSearch(self.cpus,
@@ -213,9 +234,11 @@ def identify(self, genomes, tln_tables, out_dir, prefix, force, write_single_cop
                                  self.checksum_suffix,
                                  self.marker_gene_dir)
         pfam_search.run(gene_files)
-        self.logger.info(f'Annotations done using HMMER {tigr_search.version}.')
+        self.logger.info(
+            f'Annotations done using HMMER {tigr_search.version}.')
 
-        self.logger.log(Config.LOG_TASK, 'Summarising identified marker genes.')
+        self.logger.log(Config.LOG_TASK,
+                        'Summarising identified marker genes.')
         self._report_identified_marker_genes(genome_dictionary, out_dir, prefix,
                                              write_single_copy_genes)
 
@@ -280,7 +303,8 @@ def _msa_filter_by_taxa(self, concatenated_file: str,
 
         msa = read_fasta(concatenated_file)
         msa_len = len(msa)
-        self.logger.info(f'Read concatenated alignment for {msa_len:,} GTDB genomes.')
+        self.logger.info(
+            f'Read concatenated alignment for {msa_len:,} GTDB genomes.')
 
         if taxa_filter is not None:
             taxa_to_keep = set(taxa_filter.split(','))
@@ -312,7 +336,7 @@ def _apply_mask(self, gtdb_msa, user_msa, msa_mask, min_perc_aa):
             list_seq = np.fromiter(seq, dtype='S1')
             if list_mask.shape[0] != list_seq.shape[0]:
                 raise MSAMaskLengthMismatch(
-                    'Mask and alignment length do not match.')
+                    f'Mask ({list_mask.shape[0]}) and alignment ({list_seq.shape[0]}) length do not match.')
 
             list_masked_seq = list_seq[list_mask]
 
@@ -323,7 +347,8 @@ def _apply_mask(self, gtdb_msa, user_msa, msa_mask, min_perc_aa):
 
             masked_seq = list_masked_seq.tostring().decode('utf-8')
 
-            valid_bases = list_masked_seq.shape[0] - masked_seq_counts['.'] - masked_seq_counts['-']
+            valid_bases = list_masked_seq.shape[0] - \
+                masked_seq_counts['.'] - masked_seq_counts['-']
             if seq_id in user_msa and valid_bases < list_masked_seq.shape[0] * min_perc_aa:
                 pruned_seqs[seq_id] = masked_seq
                 continue
@@ -332,17 +357,28 @@ def _apply_mask(self, gtdb_msa, user_msa, msa_mask, min_perc_aa):
 
         return output_seqs, pruned_seqs
 
-    def _write_msa(self, seqs, output_file, gtdb_taxonomy):
+    def _write_msa(self, seqs, output_file, gtdb_taxonomy, zip_output=False):
         """Write sequences to FASTA file."""
 
-        with open(output_file, 'w') as fout:
-            for genome_id, alignment in sorted(seqs.items()):
-                if genome_id in gtdb_taxonomy:
-                    fout.write('>%s %s\n' %
-                               (genome_id, ';'.join(gtdb_taxonomy[genome_id])))
-                else:
-                    fout.write('>%s\n' % genome_id)
-                fout.write('%s\n' % alignment)
+        if zip_output:
+            output_file_gz = output_file + '.gz'
+            with gzip.open(output_file_gz, 'w') as fgz:
+                for genome_id, alignment in sorted(seqs.items()):
+                    if genome_id in gtdb_taxonomy:
+                        fgz.write(
+                            f">{genome_id} {';'.join(gtdb_taxonomy[genome_id])}\n".encode())
+                    else:
+                        fgz.write(f">{genome_id}\n".encode())
+                    fgz.write(f'{alignment}\n'.encode())
+        else:
+            with open(output_file, 'w') as fout:
+                for genome_id, alignment in sorted(seqs.items()):
+                    if genome_id in gtdb_taxonomy:
+                        fout.write('>%s %s\n' %
+                                   (genome_id, ';'.join(gtdb_taxonomy[genome_id])))
+                    else:
+                        fout.write('>%s\n' % genome_id)
+                    fout.write('%s\n' % alignment)
 
     def genome_domain(self, identity_dir, prefix):
         """Determine domain of User genomes based on identified marker genes."""
@@ -350,16 +386,17 @@ def genome_domain(self, identity_dir, prefix):
         ar_count = defaultdict(int)
 
         # Load the marker files for each domain
-        ar122_marker_file = CopyNumberFileAR122(identity_dir, prefix)
-        ar122_marker_file.read()
+        ar53_marker_file = CopyNumberFileAR53(identity_dir, prefix)
+        ar53_marker_file.read()
         bac120_marker_file = CopyNumberFileBAC120(identity_dir, prefix)
         bac120_marker_file.read()
 
         # Get the number of single copy markers for each domain
-        for out_d, marker_summary in ((ar_count, ar122_marker_file),
+        for out_d, marker_summary in ((ar_count, ar53_marker_file),
                                       (bac_count, bac120_marker_file)):
             for genome_id in marker_summary.genomes:
-                out_d[genome_id] = len(marker_summary.get_single_copy_hits(genome_id))
+                out_d[genome_id] = len(
+                    marker_summary.get_single_copy_hits(genome_id))
 
         bac_gids = set()
         ar_gids = set()
@@ -373,7 +410,7 @@ def genome_domain(self, identity_dir, prefix):
                 ar_gids.add(gid)
             if abs(bac_aa_per - arc_aa_per) <= 10:
                 bac_ar_diff[gid] = {'bac120': round(
-                    bac_aa_per, 1), 'ar122': round(arc_aa_per, 1)}
+                    bac_aa_per, 1), 'ar53': round(arc_aa_per, 1)}
 
         return bac_gids, ar_gids, bac_ar_diff
 
@@ -422,7 +459,8 @@ def align(self,
         """Align marker genes in genomes."""
 
         # read genomes that failed identify steps to skip them
-        failed_genomes_file = os.path.join(os.path.join(identify_dir,os.path.basename(PATH_FAILS.format(prefix=prefix))))
+        failed_genomes_file = os.path.join(os.path.join(
+            identify_dir, PATH_FAILS.format(prefix=prefix)))
         if os.path.isfile(failed_genomes_file):
             with open(failed_genomes_file) as fgf:
                 failed_genomes = [row.split()[0] for row in fgf]
@@ -430,7 +468,8 @@ def align(self,
             failed_genomes = list()
 
         # If the user is re-running this step, check if the identify step is consistent.
-        genomic_files = self._path_to_identify_data(identify_dir, identify_dir != out_dir)
+        genomic_files = self._path_to_identify_data(
+            identify_dir, identify_dir != out_dir)
         if genomes_to_process is not None and len(genomic_files) != len(genomes_to_process):
             if list(set(genomic_files.keys()) - set(genomes_to_process.keys())).sort() != failed_genomes.sort():
                 self.logger.error('{} are not present in the input list of genome to process.'.format(
@@ -445,20 +484,21 @@ def align(self,
             identify_path = os.path.join(out_dir, DIR_IDENTIFY)
             make_sure_path_exists(identify_path)
             copy(CopyNumberFileBAC120(identify_dir, prefix).path, identify_path)
-            copy(CopyNumberFileAR122(identify_dir, prefix).path, identify_path)
+            copy(CopyNumberFileAR53(identify_dir, prefix).path, identify_path)
             copy(TlnTableSummaryFile(identify_dir, prefix).path, identify_path)
 
         # Create the align intermediate directory.
         make_sure_path_exists(os.path.join(out_dir, DIR_ALIGN_INTERMEDIATE))
 
         # Write out files with marker information
-        ar122_marker_info_file = MarkerInfoFileAR122(out_dir, prefix)
-        ar122_marker_info_file.write()
+        ar53_marker_info_file = MarkerInfoFileAR53(out_dir, prefix)
+        ar53_marker_info_file.write()
         bac120_marker_info_file = MarkerInfoFileBAC120(out_dir, prefix)
         bac120_marker_info_file.write()
 
         # Determine what domain each genome belongs to.
-        bac_gids, ar_gids, _bac_ar_diff = self.genome_domain(identify_dir, prefix)
+        bac_gids, ar_gids, _bac_ar_diff = self.genome_domain(
+            identify_dir, prefix)
         if len(bac_gids) + len(ar_gids) == 0:
             raise GTDBTkExit(f'Unable to assign a domain to any genomes, '
                              f'please check the identify marker summary file, '
@@ -473,12 +513,13 @@ def align(self,
         #                      f'genomes identified as archaeal.')
         #     align.concat_single_copy_hits(dir_tmp_arc,
         #                                   cur_gid_dict,
-        #                                   ar122_marker_info_file)
+        #                                   ar53_marker_info_file)
         #
 
-        self.logger.info(f'Aligning markers in {len(genomic_files):,} genomes with {self.cpus} CPUs.')
+        self.logger.info(
+            f'Aligning markers in {len(genomic_files):,} genomes with {self.cpus} CPUs.')
         dom_iter = ((bac_gids, Config.CONCAT_BAC120, Config.MASK_BAC120, "bac120", 'bacterial', CopyNumberFileBAC120),
-                    (ar_gids, Config.CONCAT_AR122, Config.MASK_AR122, "ar122", 'archaeal', CopyNumberFileAR122))
+                    (ar_gids, Config.CONCAT_AR53, Config.MASK_AR53, "ar53", 'archaeal', CopyNumberFileAR53))
         gtdb_taxonomy = Taxonomy().read(self.taxonomy_file)
         for gids, msa_file, mask_file, marker_set_id, domain_str, copy_number_f in dom_iter:
 
@@ -486,7 +527,8 @@ def align(self,
             if len(gids) == 0:
                 continue
 
-            self.logger.info(f'Processing {len(gids):,} genomes identified as {domain_str}.')
+            self.logger.info(
+                f'Processing {len(gids):,} genomes identified as {domain_str}.')
             if marker_set_id == 'bac120':
                 marker_info_file = bac120_marker_info_file
                 marker_filtered_genomes = os.path.join(
@@ -496,13 +538,13 @@ def align(self,
                 marker_user_msa_path = os.path.join(
                     out_dir, PATH_BAC120_USER_MSA.format(prefix=prefix))
             else:
-                marker_info_file = ar122_marker_info_file
+                marker_info_file = ar53_marker_info_file
                 marker_filtered_genomes = os.path.join(
-                    out_dir, PATH_AR122_FILTERED_GENOMES.format(prefix=prefix))
+                    out_dir, PATH_AR53_FILTERED_GENOMES.format(prefix=prefix))
                 marker_msa_path = os.path.join(
-                    out_dir, PATH_AR122_MSA.format(prefix=prefix))
+                    out_dir, PATH_AR53_MSA.format(prefix=prefix))
                 marker_user_msa_path = os.path.join(
-                    out_dir, PATH_AR122_USER_MSA.format(prefix=prefix))
+                    out_dir, PATH_AR53_USER_MSA.format(prefix=prefix))
 
             cur_genome_files = {
                 gid: f for gid, f in genomic_files.items() if gid in gids}
@@ -517,9 +559,11 @@ def align(self,
             gtdb_msa_mask = os.path.join(Config.MASK_DIR, mask_file)
 
             # Generate the user MSA.
-            user_msa = align.align_marker_set(cur_genome_files, marker_info_file, copy_number_f, self.cpus)
+            user_msa = align.align_marker_set(
+                cur_genome_files, marker_info_file, copy_number_f, self.cpus)
             if len(user_msa) == 0:
-                self.logger.warning(f'Identified {len(user_msa):,} single copy {domain_str} hits.')
+                self.logger.warning(
+                    f'Identified {len(user_msa):,} single copy {domain_str} hits.')
                 continue
 
             # Write the individual marker alignments to disk
@@ -529,13 +573,15 @@ def align(self,
 
             # filter columns without sufficient representation across taxa
             if skip_trimming:
-                self.logger.info('Skipping custom filtering and selection of columns.')
+                self.logger.info(
+                    'Skipping custom filtering and selection of columns.')
                 pruned_seqs = {}
                 trimmed_seqs = merge_two_dicts(gtdb_msa, user_msa)
 
             elif custom_msa_filters:
                 aligned_genomes = merge_two_dicts(gtdb_msa, user_msa)
-                self.logger.info('Performing custom filtering and selection of columns.')
+                self.logger.info(
+                    'Performing custom filtering and selection of columns.')
 
                 trim_msa = TrimMSA(cols_per_gene,
                                    min_perc_aa / 100.0,
@@ -560,19 +606,19 @@ def align(self,
                 filtered_user_genomes = set(
                     pruned_seqs).intersection(user_msa)
                 if len(filtered_user_genomes):
-                    self.logger.info('Filtered genomes include {:.} user submitted genomes.'.format(len(
-                        filtered_user_genomes)))
+                    self.logger.info(
+                        f'Filtered genomes include {len(filtered_user_genomes)} user submitted genomes.')
             else:
                 self.logger.log(Config.LOG_TASK,
-                    f'Masking columns of {domain_str} multiple sequence alignment using canonical mask.')
+                                f'Masking columns of {domain_str} multiple sequence alignment using canonical mask.')
                 trimmed_seqs, pruned_seqs = self._apply_mask(gtdb_msa,
                                                              user_msa,
                                                              gtdb_msa_mask,
                                                              min_perc_aa / 100.0)
                 self.logger.info('Masked {} alignment from {:,} to {:,} AAs.'.format(
-                                    domain_str,
-                                    len(list(user_msa.values())[0]),
-                                    len(list(trimmed_seqs.values())[0])))
+                    domain_str,
+                    len(list(user_msa.values())[0]),
+                    len(list(trimmed_seqs.values())[0])))
 
                 if min_perc_aa > 0:
                     self.logger.info('{:,} {} user genomes have amino acids in <{:.1f}% of columns in filtered MSA.'.format(
@@ -586,15 +632,18 @@ def align(self,
                     if len(pruned_seq) == 0:
                         perc_alignment = 0
                     else:
-                        valid_bases = sum([1 for c in pruned_seq if c.isalpha()])
+                        valid_bases = sum(
+                            [1 for c in pruned_seq if c.isalpha()])
                         perc_alignment = valid_bases * 100.0 / len(pruned_seq)
-                    fout.write(f'{pruned_seq_id}\tInsufficient number of amino acids in MSA ({perc_alignment:.1f}%)\n')
+                    fout.write(
+                        f'{pruned_seq_id}\tInsufficient number of amino acids in MSA ({perc_alignment:.1f}%)\n')
 
             # write out MSAs
             if not skip_gtdb_refs:
                 self.logger.info(f'Creating concatenated alignment for {len(trimmed_seqs):,} '
                                  f'{domain_str} GTDB and user genomes.')
-                self._write_msa(trimmed_seqs, marker_msa_path, gtdb_taxonomy)
+                self._write_msa(trimmed_seqs, marker_msa_path,
+                                gtdb_taxonomy, zip_output=True)
 
             trimmed_user_msa = {k: v for k, v in trimmed_seqs.items()
                                 if k in user_msa}
@@ -602,31 +651,32 @@ def align(self,
                 self.logger.info(f'Creating concatenated alignment for {len(trimmed_user_msa):,} '
                                  f'{domain_str} user genomes.')
                 self._write_msa(trimmed_user_msa,
-                                marker_user_msa_path, gtdb_taxonomy)
+                                marker_user_msa_path, gtdb_taxonomy, zip_output=True)
             else:
-                self.logger.info(f'All {domain_str} user genomes have been filtered out.')
+                self.logger.info(
+                    f'All {domain_str} user genomes have been filtered out.')
 
             # Create symlinks to the summary files
-            if marker_set_id == 'bac120':
-                symlink_f(PATH_BAC120_FILTERED_GENOMES.format(prefix=prefix),
-                          os.path.join(out_dir, os.path.basename(PATH_BAC120_FILTERED_GENOMES.format(prefix=prefix))))
-                if len(trimmed_user_msa) > 0:
-                    symlink_f(PATH_BAC120_USER_MSA.format(prefix=prefix),
-                              os.path.join(out_dir, os.path.basename(PATH_BAC120_USER_MSA.format(prefix=prefix))))
-                if not skip_gtdb_refs:
-                    symlink_f(PATH_BAC120_MSA.format(prefix=prefix),
-                              os.path.join(out_dir, os.path.basename(PATH_BAC120_MSA.format(prefix=prefix))))
-            elif marker_set_id == 'ar122':
-                symlink_f(PATH_AR122_FILTERED_GENOMES.format(prefix=prefix),
-                          os.path.join(out_dir, os.path.basename(PATH_AR122_FILTERED_GENOMES.format(prefix=prefix))))
-                if len(trimmed_user_msa) > 0:
-                    symlink_f(PATH_AR122_USER_MSA.format(prefix=prefix),
-                              os.path.join(out_dir, os.path.basename(PATH_AR122_USER_MSA.format(prefix=prefix))))
-                if not skip_gtdb_refs:
-                    symlink_f(PATH_AR122_MSA.format(prefix=prefix),
-                              os.path.join(out_dir, os.path.basename(PATH_AR122_MSA.format(prefix=prefix))))
-            else:
-                raise GenomeMarkerSetUnknown('There was an error determining the marker set.')
+            # if marker_set_id == 'bac120':
+            #     symlink_f(PATH_BAC120_FILTERED_GENOMES.format(prefix=prefix),
+            #               os.path.join(out_dir, os.path.basename(PATH_BAC120_FILTERED_GENOMES.format(prefix=prefix))))
+            #     if len(trimmed_user_msa) > 0:
+            #         symlink_f(PATH_BAC120_USER_MSA.format(prefix=prefix),
+            #                   os.path.join(out_dir, os.path.basename(PATH_BAC120_USER_MSA.format(prefix=prefix))))
+            #     if not skip_gtdb_refs:
+            #         symlink_f(PATH_BAC120_MSA.format(prefix=prefix),
+            #                   os.path.join(out_dir, os.path.basename(PATH_BAC120_MSA.format(prefix=prefix))))
+            # elif marker_set_id == 'ar53':
+            #     symlink_f(PATH_AR53_FILTERED_GENOMES.format(prefix=prefix),
+            #               os.path.join(out_dir, os.path.basename(PATH_AR53_FILTERED_GENOMES.format(prefix=prefix))))
+            #     if len(trimmed_user_msa) > 0:
+            #         symlink_f(PATH_AR53_USER_MSA.format(prefix=prefix),
+            #                   os.path.join(out_dir, os.path.basename(PATH_AR53_USER_MSA.format(prefix=prefix))))
+            #     if not skip_gtdb_refs:
+            #         symlink_f(PATH_AR53_MSA.format(prefix=prefix),
+            #                   os.path.join(out_dir, os.path.basename(PATH_AR53_MSA.format(prefix=prefix))))
+            # else:
+            #     raise GenomeMarkerSetUnknown('There was an error determining the marker set.')
 
     def _write_individual_markers(self, user_msa, marker_set_id, marker_list, out_dir, prefix):
         marker_dir = join(out_dir, DIR_ALIGN_MARKERS)
@@ -636,7 +686,8 @@ def _write_individual_markers(self, user_msa, marker_set_id, marker_list, out_di
         marker_to_msa = dict()
         offset = 0
         for marker_id, marker_desc, marker_len in sorted(markers, key=lambda x: x[0]):
-            path_msa = os.path.join(marker_dir, f'{prefix}.{marker_set_id}.{marker_id}.faa')
+            path_msa = os.path.join(
+                marker_dir, f'{prefix}.{marker_set_id}.{marker_id}.faa')
             marker_to_msa[path_msa] = defaultdict(str)
             for gid, msa in user_msa.items():
                 marker_to_msa[path_msa][gid] += msa[offset: marker_len + offset]
diff --git a/gtdbtk/misc.py b/gtdbtk/misc.py
index cf2e9e8d..32457539 100644
--- a/gtdbtk/misc.py
+++ b/gtdbtk/misc.py
@@ -18,10 +18,16 @@
 import logging
 import os
 
+import shutil
+
+import dendropy
+
 import gtdbtk.config.config as Config
 from gtdbtk.biolib_lite.execute import check_dependencies
 from gtdbtk.biolib_lite.logger import colour
+from gtdbtk.biolib_lite.newick import parse_label
 from gtdbtk.biolib_lite.seq_io import read_fasta
+from gtdbtk.config.output import DIR_CLASSIFY_INTERMEDIATE, DIR_ALIGN_INTERMEDIATE, DIR_IDENTIFY_INTERMEDIATE
 from gtdbtk.exceptions import GTDBTkException, GTDBTkExit
 from gtdbtk.tools import sha1_dir
 
@@ -49,7 +55,7 @@ def trim_msa(self, untrimmed_msa, mask_type, maskid, output_file):
         if maskid == 'bac' and mask_type == 'reference':
             mask = os.path.join(Config.MASK_DIR, Config.MASK_BAC120)
         elif maskid == 'arc' and mask_type == 'reference':
-            mask = os.path.join(Config.MASK_DIR, Config.MASK_AR122)
+            mask = os.path.join(Config.MASK_DIR, Config.MASK_AR53)
         elif mask_type == 'file':
             mask = maskid
         else:
@@ -101,6 +107,89 @@ def checkfolder(self, folder_path, folder_name):
                 folder_name, folder_path, colour('MISSING', ['bright'], fg='red')))
             return False
 
+    def remove_labels(self, input_file, output_file):
+        """Remove labels from a Newick Tree.
+
+        Parameters
+        ----------
+        input_file : str
+            The path to the input Newick tree.
+        output_file : str
+            The path to the output Newick tree.
+        """
+
+        self.logger.info("Removing labels from tree {}".format(input_file))
+        intree= dendropy.Tree.get_from_path(input_file,
+                                           schema='newick',
+                                           rooting='force-rooted',
+                                           preserve_underscores=True)
+
+        for node in intree.internal_nodes():
+            node.label = None
+
+        intree.write_to_path(output_file, schema='newick', suppress_rooting=True,unquoted_underscores=True)
+
+
+    def convert_to_itol(self, input_file, output_file):
+        """Remove labels from a Newick Tree.
+
+        Parameters
+        ----------
+        input_file : str
+            The path to the input Newick tree.
+        output_file : str
+            The path to the output Newick tree.
+        """
+
+        self.logger.info("Convert GTDB-Tk tree to iTOL format")
+        intree= dendropy.Tree.get_from_path(input_file,
+                                           schema='newick',
+                                           rooting='force-rooted',
+                                           preserve_underscores=True)
+
+        for node in intree.internal_nodes():
+            if node.label:
+                bootstrap,label,_aux = parse_label(node.label)
+                if label:
+                    label = label.replace('; ',';').replace(';','|').replace("'","").lstrip('')
+                node.label = label
+                if node.edge.length:
+                    node.edge.length = f'{node.edge.length}[{bootstrap}]'
+
+        intree.write_to_path(output_file, schema='newick', suppress_rooting=True,unquoted_underscores=True)
+
+
+    def remove_intermediate_files(self,output_dir,wf_name):
+        """Remove intermediate files.
+
+        Parameters
+        ----------
+        output_dir : str
+            The path to the output directory.
+        wf_name : str
+            The name of the workflow to delete intermediate files.
+        """
+        self.logger.info('Removing intermediate files.')
+        #Remove identify step intermediate files
+        intermediate_identify = os.path.join(output_dir, DIR_IDENTIFY_INTERMEDIATE)
+        if os.path.exists(intermediate_identify) and os.path.isdir(intermediate_identify):
+            shutil.rmtree(intermediate_identify)
+        #Remove align step intermediate files
+        intermediate_align = os.path.join(output_dir, DIR_ALIGN_INTERMEDIATE)
+        if os.path.exists(intermediate_align) and os.path.isdir(intermediate_align):
+            shutil.rmtree(intermediate_align)
+        if wf_name == 'classify_wf':
+            #Remove classify step intermediate files
+            intermediate_classify = os.path.join(output_dir, DIR_CLASSIFY_INTERMEDIATE)
+            if os.path.exists(intermediate_classify) and os.path.isdir(intermediate_classify):
+                shutil.rmtree(intermediate_classify)
+        elif wf_name == 'de_novo_wf':
+            #Remove classify step intermediate files
+            intermediate_infer = os.path.join(output_dir, DIR_ALIGN_INTERMEDIATE)
+            if os.path.exists(intermediate_infer) and os.path.isdir(intermediate_infer):
+                shutil.rmtree(intermediate_infer)
+        self.logger.info('Intermediate files removed.')
+
     def check_install(self):
         """Check that all reference files exist.
 
diff --git a/gtdbtk/pipeline/align.py b/gtdbtk/pipeline/align.py
index 28c1990f..af16cc0d 100644
--- a/gtdbtk/pipeline/align.py
+++ b/gtdbtk/pipeline/align.py
@@ -75,7 +75,7 @@ def get_single_copy_hits(gid_dict: dict, copy_number_file, cpus):
                       copy_number_file))
 
     # Process the queue.
-    with mp.get_context('spawn').Pool(processes=cpus) as pool:
+    with mp.Pool(processes=cpus) as pool:
         results = list(tqdm_log(pool.imap_unordered(get_single_copy_hits_worker, queue),
                                 total=len(queue), unit='genome'))
 
@@ -238,7 +238,7 @@ def align_marker_set(gid_dict, marker_info_file: MarkerInfoFile, copy_number_fil
                           marker_info_file.markers[marker_id]['path'],
                           marker_path,
                           frozenset(single_copy_hits[marker_id])))
-        with mp.get_context('spawn').Pool(processes=cpus) as pool:
+        with mp.Pool(processes=cpus) as pool:
             results = list(tqdm_log(pool.imap_unordered(run_hmm_align_worker, queue),
                                     total=len(queue), unit='marker'))
 
diff --git a/gtdbtk/pipeline/export_msa.py b/gtdbtk/pipeline/export_msa.py
index e65d9693..31340998 100644
--- a/gtdbtk/pipeline/export_msa.py
+++ b/gtdbtk/pipeline/export_msa.py
@@ -2,7 +2,7 @@
 from shutil import copyfile
 
 from gtdbtk.biolib_lite.common import make_sure_path_exists
-from gtdbtk.config.config import CONCAT_AR122, CONCAT_BAC120
+from gtdbtk.config.config import CONCAT_AR53, CONCAT_BAC120
 from gtdbtk.exceptions import GTDBTkExit
 from gtdbtk.model.enum import Domain
 
@@ -14,7 +14,7 @@ def export_msa(domain: Domain, output_file: str):
     :param output_file: The path to write the MSA.
     """
     if domain is Domain.ARCHAEA:
-        file_to_export = CONCAT_AR122
+        file_to_export = CONCAT_AR53
     elif domain is Domain.BACTERIA:
         file_to_export = CONCAT_BAC120
     else:
diff --git a/gtdbtk/split.py b/gtdbtk/split.py
new file mode 100644
index 00000000..bdfc7c96
--- /dev/null
+++ b/gtdbtk/split.py
@@ -0,0 +1,367 @@
+###############################################################################
+#                                                                             #
+#    This program is free software: you can redistribute it and/or modify     #
+#    it under the terms of the GNU General Public License as published by     #
+#    the Free Software Foundation, either version 3 of the License, or        #
+#    (at your option) any later version.                                      #
+#                                                                             #
+#    This program is distributed in the hope that it will be useful,          #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of           #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
+#    GNU General Public License for more details.                             #
+#                                                                             #
+#    You should have received a copy of the GNU General Public License        #
+#    along with this program. If not, see <http://www.gnu.org/licenses/>.     #
+#                                                                             #
+###############################################################################
+import os
+
+import logging
+
+import gtdbtk.config.config as Config
+from gtdbtk.biolib_lite.common import make_sure_path_exists
+from gtdbtk.biolib_lite.newick import parse_label
+from gtdbtk.biolib_lite.seq_io import read_fasta
+from gtdbtk.config.output import *
+from gtdbtk.exceptions import GenomeMarkerSetUnknown, GTDBTkExit
+from gtdbtk.io.classify_summary import ClassifySummaryFileRow
+from gtdbtk.io.pplacer_classification import PplacerHighClassifyRow, PplacerHighClassifyFile
+from gtdbtk.tools import TreeTraversal, standardise_taxonomy
+
+
+class Split(object):
+    """Determine taxonomic classification of genomes by ML placement using the Split Methods."""
+
+    def __init__(self, order_rank, gtdb_taxonomy, reference_ids):
+        """Initialize."""
+        self.order_rank = order_rank
+        self.logger = logging.getLogger('timestamp')
+        self.gtdb_taxonomy = gtdb_taxonomy
+        self.reference_ids = reference_ids
+
+        # rank_of_interest determine the rank in the tree_mapping file for
+        # lower classification
+        self.rank_of_interest = "o__"
+
+    def get_high_pplacer_taxonomy(self, out_dir, marker_set_id, prefix, user_msa_file, tree):
+        """Parse the pplacer tree and write the partial taxonomy for each user genome based on their placements
+
+        Parameters
+        ----------
+        out_dir : output directory
+        prefix : desired prefix for output files
+        marker_set_id : bacterial or archaeal id (bac120 or ar53)
+        user_msa_file : msa file listing all user genomes for a certain domain
+        tree : pplacer tree including the user genomes
+
+        Returns
+        -------
+        dictionary[genome_label]=pplacer_taxonomy
+
+        """
+        results = {}
+        out_root = os.path.join(out_dir, 'classify', 'intermediate_results')
+        make_sure_path_exists(out_root)
+
+        if marker_set_id == 'bac120':
+            out_pplacer = PplacerHighClassifyFile(out_dir,prefix)
+        else:
+            self.logger.error('There was an error determining the marker set.')
+            raise GenomeMarkerSetUnknown
+
+        red_bac_dict = Config.RED_DIST_BAC_DICT
+
+        # We get the pplacer taxonomy for comparison
+        user_genome_ids = set(read_fasta(user_msa_file).keys())
+        for leaf in tree.leaf_node_iter():
+
+            is_on_terminal_branch = False
+            terminal_branch_test = False
+            term_branch_taxonomy = ''
+            if leaf.taxon.label in user_genome_ids:
+                pplacer_row = PplacerHighClassifyRow()
+                taxa = []
+                cur_node = leaf
+                current_rel_dist = 1.0
+                # every user genomes has a RED value of one assigned to it
+                while cur_node.parent_node:
+                    # we go up the tree from the user genome
+                    if hasattr(cur_node, 'rel_dist') and current_rel_dist == 1.0 and cur_node.rel_dist < 1.0:
+                        # if the parent node of the current genome has a red distance,
+                        # it means it is part of the reference tree
+                        # we store the first RED value encountered in the
+                        # tree
+                        current_rel_dist = cur_node.rel_dist
+                    if cur_node.is_internal():
+                        # We check if the genome is place on a terminal
+                        # branch
+
+                        if not terminal_branch_test:
+                            child_genomes = [nd.taxon.label for nd in cur_node.leaf_nodes(
+                            ) if nd.taxon.label not in user_genome_ids]
+                            if len(child_genomes) == 1:
+                                is_on_terminal_branch = True
+                                term_branch_taxonomy = self.gtdb_taxonomy.get(
+                                    child_genomes[0])
+                                terminal_branch_test = True
+                            if len(child_genomes) > 1:
+                                terminal_branch_test = True
+                    # While going up the tree we store of taxonomy
+                    # information
+                    _support, taxon, _aux_info = parse_label(
+                        cur_node.label)
+                    if taxon:
+                        for t in taxon.split(';')[::-1]:
+                            taxa.append(t.strip())
+                    cur_node = cur_node.parent_node
+
+                taxa_str = ';'.join(taxa[::-1])
+
+                pplacer_tax = str(taxa_str)
+
+                taxa_str_terminal,taxa_str_red = '',''
+
+                if is_on_terminal_branch:
+                    # some rank may be missing from going up the tree.
+                    # if the genome is on a terminal branch,
+                    # we can select the taxonomy from the reference leaf to get the low level of the taxonomy
+                    # we select down to genus
+                    if len(taxa) > 1:
+                        tax_of_leaf = term_branch_taxonomy[term_branch_taxonomy.index(
+                            taxa_str.split(';')[-1]) + 1:-1]
+                    else:
+                        tax_of_leaf = term_branch_taxonomy[1:-1]
+                        taxa_str = 'd__Bacteria'
+
+                    taxa_str_terminal = self._classify_on_terminal_branch(
+                        tax_of_leaf, current_rel_dist, taxa_str.split(';')[-1][0:3], term_branch_taxonomy,
+                        red_bac_dict)
+
+                cur_node = leaf
+                parent_taxon_node = cur_node.parent_node
+                _support, parent_taxon, _aux_info = parse_label(
+                    parent_taxon_node.label)
+
+                while parent_taxon_node is not None and not parent_taxon:
+                    parent_taxon_node = parent_taxon_node.parent_node
+                    _support, parent_taxon, _aux_info = parse_label(
+                        parent_taxon_node.label)
+
+                # is the node represent multiple ranks, we select the lowest one
+                # i.e. if node is p__A;c__B;o__C we pick o__
+                parent_rank = parent_taxon.split(";")[-1]
+
+                if parent_rank[0:3] != 'g__':
+                    node_in_ref_tree = cur_node
+                    while len([childnd.taxon.label.replace("'", '') for childnd in node_in_ref_tree.leaf_iter(
+                    ) if childnd.taxon.label in self.reference_ids]) == 0:
+                        node_in_ref_tree = node_in_ref_tree.parent_node
+                    # we select a node of the reference tree
+
+                    # we select the child rank (if parent_rank = 'c__'
+                    # child rank will be 'o__)'
+                    child_rk = self.order_rank[self.order_rank.index(
+                        parent_rank[0:3]) + 1]
+
+                    # get all reference genomes under the current node
+                    list_subnode = [childnd.taxon.label.replace("'", '') for childnd in
+                                    node_in_ref_tree.leaf_iter()
+                                    if childnd.taxon.label in self.reference_ids]
+
+                    # get all names for the child rank
+                    list_ranks = [self.gtdb_taxonomy.get(name)[self.order_rank.index(child_rk)]
+                                  for name in list_subnode]
+
+                    # if there is just one rank name
+                    if len(set(list_ranks)) == 1:
+                        child_taxons = []
+                        child_rel_dist = None
+                        for subranknd in node_in_ref_tree.preorder_iter():
+                            _support, subranknd_taxon, _aux_info = parse_label(
+                                subranknd.label)
+                            if subranknd.is_internal() and subranknd_taxon is not None and subranknd_taxon.startswith(
+                                    child_rk):
+                                child_taxons = subranknd_taxon.split(
+                                    ";")
+                                child_taxon_node = subranknd
+                                child_rel_dist = child_taxon_node.rel_dist
+                                break
+
+                        taxa_str_red, taxa_str_terminal = self._classify_on_internal_branch(leaf.taxon.label,
+                                                                                            child_taxons,
+                                                                                            current_rel_dist,
+                                                                                            child_rel_dist,
+                                                                                            node_in_ref_tree,
+                                                                                            parent_rank, child_rk,
+                                                                                            taxa_str,
+                                                                                            taxa_str_terminal,
+                                                                                            is_on_terminal_branch,
+                                                                                            red_bac_dict)
+                    else:
+                        taxa_str_red = taxa_str
+
+
+                results[leaf.taxon.label] = {"tk_tax_red": standardise_taxonomy(taxa_str_red, 'bac120'),
+                                             "tk_tax_terminal": standardise_taxonomy(taxa_str_terminal,
+                                                                                     'bac120'),
+                                             "pplacer_tax": standardise_taxonomy(pplacer_tax, 'bac120'),
+                                             'rel_dist': current_rel_dist}
+
+                pplacer_row.gid = leaf.taxon.label
+                pplacer_row.gtdb_taxonomy_red = standardise_taxonomy(taxa_str_red, 'bac120')
+                pplacer_row.gtdb_taxonomy_terminal = standardise_taxonomy(taxa_str_terminal, 'bac120')
+                pplacer_row.pplacer_taxonomy = standardise_taxonomy(pplacer_tax, 'bac120')
+                pplacer_row.is_terminal = is_on_terminal_branch
+                pplacer_row.red = current_rel_dist
+
+                out_pplacer.add_row(pplacer_row)
+
+        out_pplacer.write()
+        return results
+
+    def _classify_on_internal_branch(self, leaf, child_taxons, current_rel_list, child_rel_dist, node_in_ref_tree,
+                                     parent_rank, child_rk, taxa_str, taxa_str_terminal, is_on_terminal_branch,
+                                     red_bac_dict):
+        """
+         Classification on an internal node is very similar to the 'normal' classification
+         """
+
+        # Persist descendant information for efficient traversal.
+        tt = TreeTraversal()
+
+        closest_rank = None
+
+        if len(child_taxons) == 0:
+            list_leaves = [childnd.taxon.label.replace("'", '')
+                           for childnd in tt.get_leaf_nodes(node_in_ref_tree)
+                           if childnd.taxon.label in self.reference_ids]
+            if len(list_leaves) != 1:
+                list_subrank = []
+                for leaf_subrank in list_leaves:
+                    list_subrank.append(self.gtdb_taxonomy.get(leaf_subrank)
+                                        [self.order_rank.index(parent_rank) + 1])
+                if len(set(list_subrank)) == 1:
+                    print(leaf.taxon.label)
+                    print(list_leaves)
+                    print(list_subrank)
+                    raise GTDBTkExit('There should be only one leaf.')
+                else:
+                    closest_rank = parent_rank
+                    detection = "taxonomic classification fully defined by topology"
+            list_leaf_ranks = self.gtdb_taxonomy.get(list_leaves[0])[
+                              self.order_rank.index(child_rk):-1]  # We remove the species name
+
+            for leaf_taxon in reversed(list_leaf_ranks):
+                leaf_taxon_rank = leaf_taxon[:3]
+                if leaf_taxon == list_leaf_ranks[0]:
+                    if abs(current_rel_list - red_bac_dict.get(leaf_taxon_rank)) < abs(
+                            current_rel_list - red_bac_dict.get(parent_rank[:3])):
+                        closest_rank = leaf_taxon
+                        break
+                else:
+                    pchildrank = list_leaf_ranks[list_leaf_ranks.index(leaf_taxon) - 1]
+                    if abs(current_rel_list - red_bac_dict.get(leaf_taxon_rank)) < abs(
+                            current_rel_list - red_bac_dict.get(pchildrank[:3])):
+                        closest_rank = leaf_taxon
+                        break
+            if closest_rank is None:
+                closest_rank = parent_rank
+        # if there is multiple ranks on the child node (i.e genome between p__Nitrospirae and c__Nitrospiria;o__Nitrospirales;f__Nitropiraceae)
+        # we loop through the list of rank from f_ to c_ rank
+        for child_taxon in reversed(child_taxons):
+            child_taxon_rank = child_taxon[:3]
+            if child_taxon == child_taxons[0]:
+                if (abs(current_rel_list - red_bac_dict.get(child_taxon_rank)) < abs(
+                        child_rel_dist - red_bac_dict.get(child_taxon_rank)) and
+                        abs(current_rel_list - red_bac_dict.get(child_taxon_rank)) < abs(
+                            current_rel_list - red_bac_dict.get(parent_rank[:3]))):
+                    closest_rank = child_taxon
+                elif closest_rank is None:
+                    closest_rank = parent_rank
+            else:
+                pchildrank = child_taxons[child_taxons.index(
+                    child_taxon) - 1]
+                if (abs(current_rel_list - red_bac_dict.get(child_taxon_rank)) < abs(
+                        current_rel_list - red_bac_dict.get(child_taxon_rank)) and
+                        abs(current_rel_list - red_bac_dict.get(child_taxon_rank)) < abs(
+                            child_rel_dist - red_bac_dict.get(child_taxon_rank))):
+                    closest_rank = child_taxon
+                    break
+        if closest_rank is not None:
+            # when we have the closest rank found, we can find it in
+            # gtdb_Taxonomy and get the higher level from it.
+            for k, v in self.gtdb_taxonomy.items():
+                if closest_rank in v:
+                    taxa_str = ';'.join(v[1:v.index(closest_rank) + 1])
+                    # All classification should be at least to the order level if a genome
+                    # is placed on a internal branch with only one order under
+                    if any(x.startswith('o__') for x in child_taxons) \
+                            and self.order_rank.index(closest_rank[0:3]) < self.order_rank.index('o__') \
+                            and ('o__' in taxa_str_terminal.split(';') or not is_on_terminal_branch):
+                        taxa_str_terminal = ';'.join(v[1:self.order_rank.index('o__') + 1])
+                    break
+
+        return taxa_str, taxa_str_terminal
+
+    def _classify_on_terminal_branch(self, list_leaf_ranks, current_rel_list, parent_rank, term_branch_taxonomy,
+                                     red_bac_dict):
+        """
+        When a genome is on a terminal branch, we can guess the low level of its taxonomy,
+        based on the RED value
+        :param list_leaf_ranks: Taxonomy of the reference leaf
+        :param current_rel_list: RED value for the genome of interest
+        :param parent_rank: Parent  rank of the genome of interest
+        :param term_branch_taxonomy: Full taxonomy of the branch , down to genus
+        :param red_bac_dict: RED dictionary for Bacteria
+        :return: taxonomy for the genome of interest based on RED
+        """
+        closest_rank = None
+        for leaf_taxon in reversed(list_leaf_ranks):
+            if leaf_taxon == list_leaf_ranks[0]:
+                if abs(current_rel_list - red_bac_dict.get(leaf_taxon[:3])) < abs(
+                        current_rel_list - red_bac_dict.get(parent_rank)):
+                    closest_rank = leaf_taxon[:3]
+                    break
+            else:
+                pchildrank = list_leaf_ranks[list_leaf_ranks.index(
+                    leaf_taxon) - 1]
+                if abs(current_rel_list - red_bac_dict.get(leaf_taxon[:3])) < abs(
+                        current_rel_list - red_bac_dict.get(pchildrank[:3])):
+                    closest_rank = leaf_taxon[:3]
+                    break
+        if closest_rank is None:
+            closest_rank = parent_rank
+        # temporary: to delete
+        # All classification should be at least to the order level if a genome
+        # is placed on a terminal branch
+        if self.order_rank.index(closest_rank) < self.order_rank.index('o__'):
+            return ';'.join(term_branch_taxonomy[1:self.order_rank.index('o__') + 1])
+
+        return ';'.join(term_branch_taxonomy[1:self.order_rank.index(closest_rank) + 1])
+
+    def map_high_taxonomy(self,high_classification, mapping_dict, summary_file):
+        mapped_rank = {}
+        counter = 0
+        for k, v in high_classification.items():
+            # if the classification has an order
+            rk_to_check = v.get('tk_tax_red').split(
+                ';')[self.order_rank.index(self.rank_of_interest)]
+            if len(rk_to_check) > 3:
+                mapped_rank.setdefault(
+                    mapping_dict.get(rk_to_check), []).append(k)
+                counter += 1
+            else:
+                rk_to_check = v.get('tk_tax_terminal').split(
+                    ';')[self.order_rank.index(self.rank_of_interest)]
+                if len(rk_to_check) > 3:
+                    mapped_rank.setdefault(
+                        mapping_dict.get(rk_to_check), []).append(k)
+                    counter += 1
+                else:
+                    summary_row = ClassifySummaryFileRow()
+                    summary_row.gid = k
+                    summary_row.classification = v.get('tk_tax_red')
+                    summary_row.pplacer_tax = v.get('pplacer_tax')
+                    summary_row.red_value = v.get('rel_dist')
+                    summary_file.add_row(summary_row)
+        return mapped_rank, counter
diff --git a/gtdbtk/tools.py b/gtdbtk/tools.py
index a2a4e241..87d6599f 100644
--- a/gtdbtk/tools.py
+++ b/gtdbtk/tools.py
@@ -16,7 +16,7 @@
 from gtdbtk.config.output import CHECKSUM_SUFFIX
 from gtdbtk.exceptions import GTDBTkExit
 
-
+order_rank = ["d__", "p__", "c__", "o__", 'f__', 'g__', 's__']
 ##################################################
 ############MISC UTILITIES########################
 ##################################################
@@ -42,6 +42,42 @@ def get_reference_ids():
                 results.add(raw_id[3:])
     return frozenset(results)
 
+def truncate_taxonomy(taxonomy, rank):
+    taxonomy_list = taxonomy.split(';')
+    taxonomy_list = taxonomy_list[0:order_rank.index(rank)]
+    taxonomy = standardise_taxonomy(';'.join(taxonomy_list), 'bac120')
+    return taxonomy
+
+def standardise_taxonomy(taxstring, marker_set=None):
+        """Create a 7 rank taxonomy string from an incomplete taxonomy string
+
+        Parameters
+        ----------
+        taxstring : str
+            incomplete taxonomy string
+        marker_set : str
+            The marker set to use.
+
+        Returns
+        -------
+        string
+            7 rank taxonomy string.
+        """
+        # return taxstring
+
+        taxlist = taxstring.split(";")
+        while '' in taxlist:
+            taxlist.remove('')
+        if marker_set == 'bac120':
+            if not taxlist or taxlist[0] !='d__Bacteria' :
+                taxlist.insert(0, 'd__Bacteria')
+        if marker_set == 'ar53':
+            if not taxlist or taxlist[0] !='d__Archaea' :
+                taxlist.insert(0, 'd__Archaea')
+        taxlist.extend(order_rank[len(taxlist):])
+        new_taxstring = ";".join(taxlist)
+        return new_taxstring
+
 
 def add_ncbi_prefix(refname):
     if refname.startswith("GCF_"):
diff --git a/scripts/create_genome_paths.sh b/scripts/create_genome_paths.sh
deleted file mode 100644
index 45b3ec42..00000000
--- a/scripts/create_genome_paths.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/bash
-
-DATAPATH='database'
-for f in $DATAPATH/*.gz
-do
-  mkdir --parents database/${f:9:3}/${f:13:3}/${f:16:3}/${f:19:3}/ ; mv $f $_
-  filef="$(basename -- $f)"
-  echo "$filef database/${f:9:3}/${f:13:3}/${f:16:3}/${f:19:3}/ " >> genome_paths.tsv
-done
\ No newline at end of file
diff --git a/scripts/gtdb_to_ncbi_majority_vote.py b/scripts/gtdb_to_ncbi_majority_vote.py
index c9a366cd..59aa1b51 100755
--- a/scripts/gtdb_to_ncbi_majority_vote.py
+++ b/scripts/gtdb_to_ncbi_majority_vote.py
@@ -40,8 +40,8 @@
 import dendropy
 
 from gtdbtk.biolib_lite.logger import colour, logger_setup
-from gtdbtk.config.output import PATH_BAC120_TREE_FILE, PATH_AR122_TREE_FILE, PATH_BAC120_SUMMARY_OUT, \
-    PATH_AR122_SUMMARY_OUT
+from gtdbtk.config.output import PATH_BAC120_TREE_FILE, PATH_AR53_TREE_FILE, PATH_BAC120_SUMMARY_OUT, \
+    PATH_AR53_SUMMARY_OUT
 from gtdbtk.exceptions import GTDBTkExit
 
 
@@ -72,19 +72,19 @@ def get_ncbi_descendants(self, user_gid, tree, leaf_node_map, ncbi_sp_classifica
 
         return ncbi_rep_ids
 
-    def run(self, gtdbtk_output_dir, ar122_metadata_file, bac120_metadata_file,
+    def run(self, gtdbtk_output_dir, ar53_metadata_file, bac120_metadata_file,
             output_file, gtdbtk_prefix):
         """Translate GTDB to NCBI classification via majority vote."""
 
         # Set the output directories
-        if not (ar122_metadata_file or bac120_metadata_file):
-            raise GTDBTkExit('You must specify at least one of --ar122_metadata_file or --bac120_metadata_file')
+        if not (ar53_metadata_file or bac120_metadata_file):
+            raise GTDBTkExit('You must specify at least one of --ar53_metadata_file or --bac120_metadata_file')
         ar_summary = os.path.join(gtdbtk_output_dir,
-                                  PATH_AR122_SUMMARY_OUT.format(prefix=gtdbtk_prefix)) \
-            if ar122_metadata_file else None
+                                  PATH_AR53_SUMMARY_OUT.format(prefix=gtdbtk_prefix)) \
+            if ar53_metadata_file else None
         ar_tree = os.path.join(gtdbtk_output_dir,
-                               PATH_AR122_TREE_FILE.format(prefix=gtdbtk_prefix)) \
-            if ar122_metadata_file else None
+                               PATH_AR53_TREE_FILE.format(prefix=gtdbtk_prefix)) \
+            if ar53_metadata_file else None
         bac_summary = os.path.join(gtdbtk_output_dir,
                                    PATH_BAC120_SUMMARY_OUT.format(prefix=gtdbtk_prefix)) \
             if bac120_metadata_file else None
@@ -101,7 +101,7 @@ def run(self, gtdbtk_output_dir, ar122_metadata_file, bac120_metadata_file,
         ncbi_taxa = {}
         ncbi_lineages = {}
         gtdb_sp_clusters = defaultdict(set)
-        for domain, metadata_file in [('archaeal', ar122_metadata_file),
+        for domain, metadata_file in [('archaeal', ar53_metadata_file),
                                       ('bacterial', bac120_metadata_file)]:
             # Only process those domains which have been provided as an input.
             if metadata_file is None:
@@ -249,13 +249,13 @@ def print_help():
         The output file to write the translated taxonomy.
 
   {colour('At least one argument is required from:', ['underscore'])}
-    {colour('--ar122_metadata_file', ['bright'])}
+    {colour('--ar53_metadata_file', ['bright'])}
         The archaeal GTDB metadata file (if processing archaeal genomes).
     {colour('--bac120_metadata_file', ['bright'])}
         The bacterial GTDB metadata file (if processing bacterial genomes).
 
     NOTE: Metadata files are available for download from the GTDB repository
-          https://data.ace.uq.edu.au/public/gtdb/data/releases/latest/ar122_metadata.tsv
+          https://data.ace.uq.edu.au/public/gtdb/data/releases/latest/ar53_metadata.tsv
           https://data.ace.uq.edu.au/public/gtdb/data/releases/latest/bac120_metadata.tsv
 
   {colour('Optional arguments:', ['underscore'])}
@@ -268,7 +268,7 @@ def print_help():
     parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
     parser.add_argument('--gtdbtk_output_dir', required=True,
                         help='The output directory produced by the GTDB-Tk classify workflow.')
-    parser.add_argument('--ar122_metadata_file', required=False, default=None,
+    parser.add_argument('--ar53_metadata_file', required=False, default=None,
                         help='The archaeal GTDB metadata file (if processing archaeal genomes).')
     parser.add_argument('--bac120_metadata_file', required=False, default=None,
                         help='The bacterial GTDB metadata file (if processing bacterial genomes).')
@@ -295,7 +295,7 @@ def print_help():
     try:
         p = Translate()
         p.run(args.gtdbtk_output_dir,
-              args.ar122_metadata_file,
+              args.ar53_metadata_file,
               args.bac120_metadata_file,
               args.output_file,
               args.gtdbtk_prefix)
diff --git a/scripts/rename_UBAs/prepare_gtdbtk_package.py b/scripts/rename_UBAs/prepare_gtdbtk_package.py
index c2009802..8c7a2ed3 100644
--- a/scripts/rename_UBAs/prepare_gtdbtk_package.py
+++ b/scripts/rename_UBAs/prepare_gtdbtk_package.py
@@ -182,7 +182,7 @@ def run(self, dirin, dirout, gtr, release):
                 copyfile(genome, os.path.join(
                     fastani_dir, filenamef + "_genomic.fna"))
 
-        for dom in ['bac120', 'ar122']:
+        for dom in ['bac120', 'ar53']:
             # MSA renaming
             msadir = os.path.join(dirout, dom, 'msa')
             if not os.path.exists(msadir):
diff --git a/scripts/verify_official_package.py b/scripts/verify_official_package.py
index d2dbd080..6a2ad421 100644
--- a/scripts/verify_official_package.py
+++ b/scripts/verify_official_package.py
@@ -70,7 +70,7 @@ def run(self, outf):
 
         # Archaeal genome MSA is untrimmed
         ar_msa_file = glob.glob(os.path.join(
-            self.pack_dir, 'msa/*ar122.faa'))[0]
+            self.pack_dir, 'msa/*ar53.faa'))[0]
         ar_msa = read_fasta(ar_msa_file)
         first_seq = ar_msa.get(list(ar_msa.keys())[0])
         if len(first_seq) != 32675:
@@ -95,7 +95,7 @@ def run(self, outf):
 
         # Archaeal MASK is same length as the untrimmed archaeal genomes
         ar_mask_file = glob.glob(os.path.join(
-            self.pack_dir, 'masks/*ar122.mask'))[0]
+            self.pack_dir, 'masks/*ar53.mask'))[0]
         ar_mask = ''
         with open(ar_mask_file) as amf:
             ar_mask = amf.readline()
@@ -105,7 +105,7 @@ def run(self, outf):
         # Archaeal Pplacer MSA should have the same number of genomes as the
         # Archaeal untrimmed MSA
         ar_pplacer_msa_file = glob.glob(os.path.join(
-            self.pack_dir, 'pplacer', 'gtdb_' + version + '_ar122.refpkg', 'ar122_msa_r95.faa'))[0]
+            self.pack_dir, 'pplacer', 'gtdb_' + version + '_ar53.refpkg', 'ar53_msa_r95.faa'))[0]
         ar_pplacer_msa = read_fasta(ar_pplacer_msa_file)
         if len(ar_pplacer_msa) != len(ar_msa):
             print('ERROR: len(ar_pplacer_msa) != len(ar_msa)')
@@ -140,7 +140,7 @@ def run(self, outf):
         # Archaeal Tree should have the same number of leaves than nomber of
         # genomes in the MSA
         arc_tree = dendropy.Tree.get_from_path(os.path.join(
-            self.pack_dir, 'pplacer', 'gtdb_' + version + '_ar122.refpkg', 'ar122_' + version + '_unroot.pplacer.tree'),
+            self.pack_dir, 'pplacer', 'gtdb_' + version + '_ar53.refpkg', 'ar53_' + version + '_unroot.pplacer.tree'),
             schema='newick',
             rooting='force-rooted',
             preserve_underscores=True)
@@ -164,7 +164,7 @@ def run(self, outf):
             print('len(list_leaves): {}'.format(len(list_leaves)))
             print('len(bac_pplacer_msa): {}'.format(len(bac_pplacer_msa)))
 
-        # Taxonomy file should have as many genomes as bac120 and ar122 MSA
+        # Taxonomy file should have as many genomes as bac120 and ar53 MSA
         # combined
         tax_file = os.path.join(
             self.pack_dir, 'taxonomy', 'gtdb_taxonomy.tsv')
@@ -178,7 +178,7 @@ def run(self, outf):
             print('len(tax_dict): {}'.format(len(tax_dict)))
             print('len(ar_msa) + len(bac_msa): {}'.format(len(ar_msa) + len(bac_msa)))
 
-        # Radii file should have as many genomes as bac120 and ar122 MSA
+        # Radii file should have as many genomes as bac120 and ar53 MSA
         # combined
         radii_file = os.path.join(
             self.pack_dir, 'radii', 'gtdb_radii.tsv')
@@ -204,7 +204,7 @@ def run(self, outf):
 
         print('\n\nVERSION: {}'.format(version))
         print('Length trimmed bac120 MSA: {}'.format(len(bac_pplacer_msa.get(list(bac_pplacer_msa.keys())[0]))))
-        print('Length trimmed ar122 MSA: {}'.format(len(ar_pplacer_msa.get(list(ar_pplacer_msa.keys())[0]))))
+        print('Length trimmed ar53 MSA: {}'.format(len(ar_pplacer_msa.get(list(ar_pplacer_msa.keys())[0]))))
         print('')
         print('Number of genomes in fastani/database: {}'.format(len(list_genomes)))
         print('Number of genomes in radii file: {}'.format(len(radii_dict)))


Test patch:
diff --git a/tests/data/example.faa b/tests/data/example.faa
new file mode 100644
index 00000000..38599d1f
--- /dev/null
+++ b/tests/data/example.faa
@@ -0,0 +1,10 @@
+>GB_GCA_002495675.1
+RGTDRIVFRACFMLKILIATVIAGAFATVSHIARDGVNATGHDLDAAAHVPKLEMMQGIADGRGDVEVANDKAFLSNQNKVRLFTVELVEILSDIIIGGMMRSKLITMATRAESGQFSIHFE----SFTLKNRRAAQGIDPNRRKEPHTRYKLATLERAVVENISTSPMAREGFQRQIVVRGIPSNQAYEVVFYLIHIKSSGAALKKGKLEDNYRCVLDTNGPIKKATLCRVINTGTYTLDTIYSTGDSLPI------ADQIVISDRCPCMYTLAAATSVPEAYDIQIWRMYGWRDFEDGEDFSHTGAGRQRVDTGFVITKSKRAWGNITPVMRKQ----------------------------------------------AGSFYNKIDGGLEISDTTMRPLKSVSKRYRLVQNIVR-------------MSYDKSIIDGAMPATVESQAYSNLVRPRPAVIVHHELVEIETEELSPWMTDPAVQGWANRLIHSPSGSAYLILIVSKVVAHLYKNYTERTAGDPEEVLDLKLRRMFVGHIDLDD------------------------------------------QSWPAEVVEVRMTTQVKVRVNAPNGIITVVPVRVLMKDGRRLLTRGGKESRVAAASMDSRYALLFLMPDFSGIADEHIILGIIAASHRIPTAQKDDEGKRVNGRAEKGGHRNHWTLTPSAKRSLKNKHETTRMVIAAKNLTYVTFKGRTYVIADAASIPYVDHK-----VCMDSGAKFGSMISFGIGAIGMDSGVESYIMFGVALGFVQF-EWRRGNQKYIHRKISVGLEVVKDLLNDRAGVRTNRAGLRILGQCVLEARYLVGALMIVLMAGASVSRWVRKASSRLHTE----ALYAGMGKNGEASPIAGLMGSLRSSATFALALMIALLPIIYPVKMVLVELVHDV--SKFSLIVLYEERQCTFGEPLRSATIELG-----VTSDEGLVGLMIVHTKVRGVHIASFTL-DSESVPDSR------------------------------------------IVVGETLQAVTHPNKLLKDVGIVDLSRRIESITLITQEDL--LFATVAIGSYMLESVHENHGLCFQAEVAMSAVVMRV-------------------------------------------------------------TFSLSEANDHAELMSMRVIASEIEDTVQHTTGKIGAIVWIVNPAITGRLIAPHLLPSVVLNKIVRDLNVMTVLELRIRVVVERRLIVEVVFVAMMLMCYDYVGVE-YPG-APD------------------KEELELSPLGISWQVIQSLVQD----DLAFYALEGPD-LNDWIVEANIVLSFIELADEVTCYGARPELKIEGTQMFRLNHDEYFTPDDDPELYLKGKDSKLSIIDM--------------------------------------------ACLEIESTLISPITMAIADRLFLQFTLGVI-PFNPIIVVDDV------------------------------------------FFRGELSIPVLMSLIDSYSETYIVDKQPYIKRFSMENALIS--TTLEDTPKRVDQVMVTVEACRDKEIKVALQQFDASAATGDD-DTVCTAHSMWFDQHISEIGIVELGRFSGSMRGVVDHDQLA-SSDNQTEVDEHLRIIIATEFKEASRDRVDLEDCKVDDVGERD-NIGRLVRHIGSKGVLEEDRLAGAQENEDIARSFNITHPLVN-------------------------------------------KAFVARGVTRDRLFRIRLIVMNRVGGSVKRRLKISTVTA--AAYVRYMNFTVDITSNAGAVYTGSQRLRGESTEARKMPIKGEMVIVLKLSLACMECRPYRVLVLLLGMILVAGTVASRKDKSEQ------------------------------------------------------------------------------------WMSRKTLKYRKKIFAADQRHTRMSISSNPRRNKAIELVRDVLGLIICEWHDWPASLDLSVARVPLVVKRASKINGNEKILPALSHIVESDEFNILGVMSGAALCGTPEPAVVAEEASILGPKATRL--------------------------------------------GRAFLPSCTQDKGAGIAFTHLNREGAIMAARAETVLSEEVASREFVGIMHIDAGGTIAKGGVGGDRVLTTSAIMDTIEGPTDVIMLITIVRVAIIGQVIKCNGVVVAIARLELKMEGVIGLYPL------------------------------------------------------------------------------------KRFVIEAGGRLEATTDA-RGVSRMYYFPYGWDDVWSIHLLE------------------RADEVAFILFYVNESELMDLAVT--LKTSNVKIDISLQKVVRMKSPDLKAGGRVTSKEVTVELVPVR------------------------------------------------------------------------------------SIDPILNGTLLDPLVGAVICIAEHQLDAGKMPVDIAPIEEMNAHLAAVEGMVAMSIGMSIISMAADGSPQYARLLLPRSLNAPG-VGAEESSMMHNIWMSILIIKMSKLLGPAIEVEILIERKHSKIETRPGEEREETGKIGQALNIDAVSAIPIALVGTSIPSIGLI-GL-LRNKHEDDGDPSLRNIAVVKGHLARGIKKDEANRPIRAESICMVSEVEMNDPSLLEHFMIVPDIEHCFSHGDTQLDDLATYAKGSSPKPLRHWIKRAPREKIKNQHGHMIKDRTDQTDE-SV-QELDEGPPQTMEWHGVNPPFTSSIYRVYPWKITTLLDIEPLTTHNRLVSPFPEEEDLPDRVPGGLTTHTILRHVTKSLVWADF------------------------------------------AAVV-EIFWVGNAAETERTTLA-IKKDPLWELRIKAAIEERHKKSWDHGIDIEEGSDAVCKLTEYIDTAKEEWLIRSCDNVFSL------------------------------------------ILIPGTHRLGSTFTKLDSLPARDGTQSITDTLNSTLVIGGAAFPIV-L-NHWLNMLALEDATPSGGEDLGGWAMCLLTPV-LCMDSIWPIYEILLNITSTIYLADARMLATPLSDIMLFAFMVWALDLIMLDEPLGGELS-GIIAYAAAGHATMVLGDVVPGIVITT-VASIDLGRIESAFAIVSVLPIGNKVNFRMDGNPIA-LPHTATSPLSVRSSKEDWYQSVLADQYVDHKINAKPDRFSACFCALTT------------------------------------------RRTGKRGTEVQVRFLQLDMERGFRVIVSAKHGATAKLVKGREAHDRFLDLIDRFLYSYPQAIIILMSQAEAICANLKSYLLRAAFPDHIELILRRNMIGYELSDLSSVYFGSSSLIVHSIVGYKEPQRMEILNMRVDLPLVNLVVQLIAKSEIKTKDRKDSTFTFNLRFMDKMPLDIAREKLLEN----VVVVGIRVEHAMTRTGPGSVL--------------------------------------------ARVNVHHFRKTQIYIEAIPYARKKGPAYYFADRGISIFL--TTENEVVCTIRSSRKVPCRKATEKLAKDTALRVLIPIVTELHKIDSLGIQKLDRT-MLEKHEILAFSPSQPFRVLTKLASKMLIRSLGNVIGISPGMFYHLGERILSFISYSKLYKSETLMTSI-VFDQLASVALIAAIRYK-PRKFPMVLYSQKDLRNGHETSRGLKQKQKAYNAIHRATDPGRTIVVVFATGDVSIGPLAIVVDTPIGRQHLKTFSDMLVDPRQVTDHGRLFVVRGELRIKTVARVGELSRVRMLLTVAPRQDGVDTGVAISSSSEDAALKVLPHKGYFGD-------------------------------------------VLLTILSVEIGPELVTPGAEVVNLRAIGKVVMAGDDEAMKFFLGLLSAVAAESEWNTDYAYSESLGSPISRTMPLVVMSLSW-TDMLGNSRSQLFGAIQMAVPRARLKVTSALVAIGARIAEFTI------------------------------------------------------------------------------------ISIMMVATEKVALTDAKNVYDLLGLVVQSITETTTIRDGIPLKSAEHKFEFMAQEPETEVMEIMLGF-VTQNTEETKGKVSVRV----------------------------------------------RNQKLPYCDDLSGSTTEKERDIGS-MYQEFVKNSQLNKQRVVERPEPLRKVANSITVGDVARLHDDLRELRTVPRKEKMK------------------------------------------------------------------------------------------------------------------------------ISKNSIDTVCIHRIEKAYVNIEVEQVINDTVRGQANIEARSKLGETSEGTTGVPVLRLARIDGGRRDIRSFGSTVILGIDEVERINDIGVAAVLMHPRKIAVAKFSRLQVFVTVMGMGKHSIKVAR------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ETTDEYSLVAGLADEQEPRKVQSVKGIAKVIGILCVEPGIGIDIRKFHWMYILKAARMVGEMVPV-IGSLDEVGTLEEETRGAE------------------------------------------SVGSYHRADRGSVLCVIRGVGFFPKQIVADHARMERSCITGT
+>RS_GCF_003173335.1
+RETDKCVVECIAMHTIVLMTRSVARLGGMELVPGRAIEAAHGNVDAATRCPRIGLMKGIEDGRGQVASLNEYLIMSSKGRVELYDIEIKRLAEYVLMGAVIRGKALKMTTHAGEGSLHLFFKLYLKSINMSQRNGVRGMGPAPREEPVLRWRRLSDEAIVIEQVSTTPVLWEGIVRQIIVRGYTARQAYEAVWYLLHIINGGSARRTGKCGKHYRILRDKKGPIEEASLVKITNIGILNLDNVYKSGDVLK-VKIYNSADHILPKCACTCVLTMVPSIDVRPALNIQVEYMRGWVDYDVGNDYTNVGAGSLTINSGCVCTDQQIDLGKVEPVEIK-TDVDLALKKEAFVTGTRMDDYVVEVGNSPNSKSSSQKSFLGVKVVSAGAYAGKIDGGIKISDRNARKL-RLMVHTRVEQDIVKE-RKKKLRELVTVIKFQKHICEPSMPKTVIGRAWENVSRPRAQVEVEHSIMSEEKNLFARYIEQPAVQGAISDIIKSRTGAAYLVMIVTKVISTAYEEYKRRRENDPKKILDLGMDCMLLTHKEIDEQVLKVRRRSAKMKIRLGKHMKSDRLQDINERIRTKVRRAKED-GTPAEVIEVSMHMQVKARILGNKGIITTVPIRVLMLEERKL-------PRVAAAAVNNRYTVLIIQRDANKLLKNGNIITVIGAGNRFPQASREDEGAHRNGRAMRGGPRGDWRLERSAARTMKQTF-TSRIHAKAANQLVLNFLTQVDRVTSEMKILYIKGMSEET------------------------------------------DGVKTSRQKAPYGSPAVGMEIVFDLVDARATVRENKAKIRILAKLLRADGILCVALMLVFLFGTQIRHRFRQLGAKILE-A---GLYPIAGGKNRVGPWIAFLKSIEGGWQFVIGLFITILPLIYPAKAVIADILHRWALVLLTLIVLIT-RKASFGESLHNMTLECDPQELLVKANQYLEGITVVETRLKGIRIPIFRVLPGNQLPKSMIEQQQQQYDAQMALIEEENTIKLPDREVMANGISIQVTPRFI------------------------------------------LLAAAIAGSHIILVLE--PHLCYSAEIKMTCLIIHKEETFILKTLDMLAVNKMKVS-GMPTVTKMKYILDVGVHIAANVEIKKRSMYLRRSHANQITASELVQALDKASIMEVRAVGRELDDLV--VTNKADAIIYMVNPPLTEQIFAPAMAPTVILGEVVLTDRFFE-VPVRMRVYVERRMSKSLFAVAFIMRIFDYVEIGTYSLTGVDINGNRVQVLEL-LVYIGQFFRDEVDPPGIKIEIIPRMLEDLTDISLEYYAFEVEGDLKKLLYTANVKIDLLRLKDGAEIYGARS-VRLQGFNALKILDTDVVIQF-DPVLTVHKADVKPLALGLLSIEIKLEVSGDLTGVALGSVLVSNYAHQYIKEKWKLMKERIAEAALRLDTTRIEPIVIAIADLLGVPFVMGPLKPVNPIIVCST-MVGKLLDCKLSIVPRLMGRVQPIERAGVDLFNEVDIGTISK-FAAAIEVPLVYVTFISAYNANFIYDCK-YI-KLAMEIGFARLIMGLEESKGGEDSVLTTVQIVQEHIGRVAVRSSDVTAAVAEDSDHLINCLEVRYIFLLFEVSIVELGRF-GSRRAASRFERLVITCPDLTPTEEALKIIVRLGLEQYTAKEMGQDSAKAQGIKEEDTNIGELVRGIGSAVVVKEDRIARIGIPVGVLKPPCITSA-SDGNRKMKDIKEQEVTKGYFQAMTWQTFIEVTSVTAKAVTDIEIAEAKIVYGTKSLDGYRIRLMQLMREKGELKKKLDLTSHTGRIVNYIKFMSFVVNISINRNHLYTGSQRLRNQSSAIRHHPLMKEQCIIVKMSRCAIGAKPWLVLVQLEGIALIAGTAAKSEDKGSSDLGRRDAEERATESRTAQHEVREKDMKLIKERAGGSEDVGLHQLYLTQYSSELGEANATQFISDVQNISQRKEMANLIIRLE--WRSRKTYCSRKRIETGIRRNKRLEAKETPRRNRAIRMARHILV-HLAPLDDFPAGGTYVIGVGPFYLASARMSDMGDKSLPLLGFVPEERETHLIRLLEGAAIAFEEEPGVAIPEIQLCGGRATRLLKSPVLYGDD---DAISVYRDTGPESYMVVRSEVLRQHAVDITPDNGFVPHATADKDA-IVLVGFAREGGLLL-NLQVTPSSDVASKKIAASEIIDAGGASLAPYIGLKKLLTSSAIQNSVEGPREVILYINIVSAIILVSSLKCDGIISCIAKLSTVMPKVLGIFPFILIRFYAVTENVNTTLELLLDSDIILRRCKESFNTLTHFNAAFIYILVYFFYFQLQFLYQALLRADDGLRGIPAIEVVESIDKDDDFMIEEDKKLESETDIG-YVTVLYDFPFGEDEVWSMYLIDVPRVGFDAACQYIECNAWHCTNVAFILFYQEHVSVLDVHAI--VKTTSVDIDVSIDKVLRVTTTEGKPGNVVDSKEITVELLPVRYMKVKEKTPYSHAITYVAIVIDTKYISVVKEPRITVLNAWRADIRFTSWSPEGYD-SLEIQRITIQRGQ-HFAHKRQARFVMI---DRMVSTTILSDAVLALICICGRTLDAGRIPIEIAKISRQGGGLAAIQIPLELEFAMAVVASCADGTPPHKNLLRSREYRGFI--AATENSMVFGLIADAVVLKIDQLFGPSV-V-VLDESSALTLSKRPGDESKLRGEMGYGLQVEIVTALPIQHVGSTLPSIGLL-NV-LRYPYAEDKDEFTSEHFILKGFDTRAIRKDEVHEPLDAEELAVISEIEINEENMAEHAMILPEITAEMSMAMSDAGNVLVAAVPGSPKPLREMVFRGAREFGRTSYGQIITDDTGEFESGQIQETIGTGIPQEMAVHGIHPPYTNTLFRFYPILITIVLTLQSVVK-GRLISPFPFEKGLPDRCPGGLTSNLIVKRV-YALYFAHFSGEGAVFVMRVLEVAEPMENLQVIRKLHAILGEAAIVAMLVFSAVDNEIVYVASAAQEEKQTLV-VQH-PVWRIRMIAAIEERPAVPLTQFIEADTQVARVTGLGEVVDPAKEH-GLGPDSYVATTVSKAASECGDTPVTAAMQMVAIILSRDIRDHPISYSLKAPENTFILYSKILSGERKPIDGLPSRNGTQNCSNRISITYAVGGAEFPIV-P--ICFV-LSIDQAMAKGSSVIA-PYMNLVHPQGICMDELHVIFEMLLKMRCTIILADILILTTPVADIMIYLVMAHVLHIIILDQTPGGSMGVVVAALSFGGHAHLVINDVLPSNVIMVEVAVN-LGALETAHALLCALACDVGEVIRADGEPIFTPPQSETEPLENHGSRDEYDVCIVTNLFIDHKAISRDQSIVAVEALGDSKKDFPARTGKLSEGLIVKIRVNQVGDGAINIDEIGIRLSIVVDHLGDRGTQVFPKYVSIDMERGYKLIVSAKYGAVAKLIRGQHGHDNFIVIIDKFLYAYPDSIIAVVLQVEAICTNTKSYLLKN-KKQRIELVLKRKRIEVDISNIDTQYRGSQQFITHAIIGYVEPVGQEIKDLKPDFPLVRVIVRFQAKSEMLTIDKLDQTYMFNTRFIDRLSLDLNREKLLSEGR--RLILEIKVEHYLTRGSAGSVLFNRDALMSCQNMIVQERIDIEVATGTGIPSVTIGPAAEESAEKDGRNEISHFKMLDSYLEKIPFVRKGDARYHYVKEGRTLVVEKRTTDQVVCEIEATRKVPIRKSTQKIDADRALRLMTQVIGEIHKIDNYGIQRIKRIEKVDLHSILAMPLFHPYRVITTLAEKTI------------------------------------------VIGLIASVALAAAVRYEG---FPHIIYREKRIKEGEYKSTGLSQKQKAYNAHHGAKLQKRSIVKVHSTADVSVGPRPVVILEKLRRQKMKEITDTVVQSHELPRHGVVFIILDGLTLDSAARIGQLGVTKLLLHICPTRDGVNIGLEVKESGSEAALTVLPHKKVYGN------------------------------------------IVLLLIADLGGAVEAVIPGARVIKLLKVIVVVKVQDDSLDSY--RAIGAIASRSGWRIKAAFSMSHGSTEARCIYDHVADVGMMILELGDDQLKLFGSIQMVEPNARLKVTGSLVVIGTKIFEFEMVAILEFRLQELKSIILQGSQRVAGLGRFPISGRELKKETPTVIKQNQMQQMSQERAVLNDSAVVTVKVKTIREKQKMFKLNQRE-KIMMMATEGAWIAEGRKIYEVIDLVNNAITSLETVSDGIPLQVAGHKFDKMAQEPDTEWMWPAINLDVSRDTERTSGKVTTKVLLILRMAEEIVCRKSIIPMPEKELPLGLQEVGVYALAAERTNAGEYVHKRATYAFKLAKETSEREVSTGKEMYQEFVRARKIKKNRVLPVTSTLMKLLGDVSVGEVARIKNDMKVHVSVSQKEKHKKGHIYATIVLTSVNESQMGQAKHVKAPKQRSAAAAAMRISRPINFVTKVRTKFIAAVEAASVDRVIMRKIYGADDLKIAERKIRYAKASERDGQIIVDKASIKIEFDQVTVTMTNKMVFKAEEILLVKGYPISRFTMAAVLKVYVEIERGTVVTETVKGSANIEARS-LKQTDEKEEGI-EAKFSILDADRRDSRDMAKTIIEQVKSVEKINDVGIAAVLLHVQDLAIGRYNKITSILAIMGLSRYSLKRTR-IRLRAGIDILDVDVVVYEDSPIKVSEDPLFWLFELNKPYRLALVSYQPYAWGVKAAGRAPIRATE-LKTAGRVNLKNNVTALGRTGKVCVVFGHGRRGLIATSDKVKRSRSEVVDNTEIKVVYGIAQFLSDDSFFVRKWYGPQADFTEDDATFGA-DYLLCDSVKTEYVKEAARISIGLVGAGCKPYLFNKQDIESVKKIIDIAAQIAANTVDRLTPAAGLMDRKQPREIDSIRGVRKEVEILLVEEGIGLDFPEYHWLYIVKADRVMGSIAPIDLFALKKWGTLDERSSTASGKEETLDLLSALFPIMSVPDVKAKPIVDERPAALLRTWHDIWSFDLYHTVDRGTALCVVFGVGFHPLRYVDPLAQMDRALGAGL
+>RS_GCF_900095385.1
+RGTPRIVIECVAMEEAVLMTRSVARLGGTETVPGKAIEAAHGNIDAAAKVPKLGMMQGIDDGRGGVQSTNDYLFISSKSRIQLYDVEIRRGIEHVVMGAVIRGTAVKMATHANEGDAQLFFKLFLKSVNMSQRFGTEVIGPEPREEAMLRYRRADSEEIVVENISTTPVLWEGIVRQIVVRGYTARQAFEAVWFMVHIKSAGAARRRGKTGKHYRIQFDVRGEIAEATLCKIRNTGVLNLFNIYRAKDVLG-VRIYNSVDHILLECACSCAYTLVPSIDAAPAEGIQVEVVTGWLEYADGTDYSNVGAGSMAIPSKKLCTEQVAAFGRVTPVETKQTDIDLVLKNDAFATGVKMNDYVIQAGNSPNFRGSIQVSFLNLKIISEGSYAGKIDGGIRITDKTSRRLRRLSVHMRVEADIVKE-RKKKLRKPVTVINFQKHVVEPSMPKTVIGRAWEDVARPKAQVEVDHQIMDEEADLLATYIEQPAAKGGVGNIIDSRTGAAYLVMIVTKVVSTAWKEFKERRAGDPKRILDLGLERMLLTHKEIED-ILKARKRGNTIKIRLERHMKSEKLKSINEKVNSKIRRAKEDNGTPAEVIEIMMHQQVKCRVLGNKGIITTVPIRILSLEERKL------GPRLAAANMDRGRAMVYVQPNANKLRPGHVALPAICAKNRFPEASRNDEGRHKNGRAMRSGPRGRWKLDRGASRSLAQEF-TSRIQEKAANLIVETFKMELRRIDDEKTTKYLKGEPAS--VVQAETARFGPILALLMGTRSLDVLANHYIIQVVILFLLKYKGLRKVRQKAPYGAPAVGMEVVFDLLNERGSVRGERAGLKVLSDILRMESVLIVALMIVLLFGTQVHNDVRKLAARLYPE----LIYPAAGGAGRVG--FATLKSKEGEWQLVVGFLVWIIPLIYPFAAVVADVLH-VFVVLLTLVVVYEVRKANYGTSLRRATLECDPQELLVVANPGHAGVRVTDTRIMGEKIPVFRFLPGDSLPRG-LQQRQMQIDARAALIEEENTIKLPEKEVMASGVTLQLTPRFIIAVGEILRAVKYADEVLDDVGILKIPRRLNSVTIIGEEG--LLLAAAIAGAHIILVLT--PHLSGDAAREMSALVLAAPGDLLIKTLDMLALNKMKIS-GMPDDITMRYVLDMSIQIAATVDIKKRGMYLRKSHANQLTSAALVDELEKANLMELRAIAKELDDLVTHVTNAAEAIICLVNPPITEDEVAPVIAPAAVLGEVVRDTELF-MVELRDRVIIERRIALELFAIAFIMQAFDYVEIGGYPSTGAEENGSRVQVLELQAVYIGEYFQEEVDPPGIKVEIIPRMLRDVT-IAIEYYAFEVTGEAKPVLITANVKIHLLSLKENVDLYGARP-ARFEGYDALALIDQDVKQRF-DPELVVVGRPLLATALGLLQIACDIDVSGDDTGVAVGSLLIANYSHTMAFDPKSGSKEQAKEAALRLESARIDPILCCVVDMTAVPFVLAPLKPVNPIILCAECMVGKVVDCRVSIIPRIIGRVQPVEKAGVDVFMELELGIISK-VAALVEVPFIYLTFVDAYDEDFIFRGR-YI-RLAIERALARVIMVLEDAHGGELRVLTTVDITQQHIARVAVRNADVTATVGDDQDHLVGDFEVRHNALVFEVRIVEVGRL-GDLLTATEFERLAITCPELTPTEEALKIIVRLKLEQYTEEEMETDELRVEGAREEDGNIGELVRGIGSRGIVEEDRIAKVGEEIGVVRPPGITSL-DDKNKKMKEMEEEKVYAGYFDATVYQTFIDVAGATERAVTDIEIVPIQIVHGTGGVDEYRIRKWTLKREKGDLKKKLNLTDGTGSFVAYVKFMEYVAEITINRNHIFTGSERLRGQSTQAKRYPIR--QCLVIKMSKCIIGAKKWLVLAELEGIPIIAGTAARSEDRGDSDLGRRNASERAAEARIAQFEVKEKDVKLIRERTAETEDRGLK---LGQMTAELADGYVKDLISDVEAVEGRTELAKVLIRLEAAWRSRKSYHSQKRIETGERRNKRLEAAETPRRKKAIKMARDVLV--LGALADFPAFGTYVTGKGPFYLAAAYSRDEGTRSVGILAYVPAADETQLLRLLGAAAVAVEDEPGFAVDEIALVGGRATRFLLRPVIRRGGTQKDVHKVFSDTGYKSMLVAGRSVHKKMAIYIAPDTAFVPHVTAEKHARVILAGWQREGMLALRDARATPSPDVASARIAGAAA-EMGGAALAPYVAKKSLLTSSALAATVAGARE-ILYIKIVCAIILAEMLKTDGVIKVIAKLE-VMEGVLGIFPFILLRFHAMTGNVHTTLELLLDEQDVLARLAEEFMKVTNFNADFVYVLVYFFYFQLQALMEAILRADNGLRGIPAVDIITTVDPENEFLIEENEKLKVETDVD-HITILYDFPFGEDEVWSIYLIEVPRIGFDTSCEHIDCNAWHCTDVAFIVFYADEIGVMDVQAFAIIKTTTVDIEVAMEKVLLIATAEEKPGAVIDGKEITVELVPVRYMKVKEKNPYSHTLTYVGIVIDANYISVVGEPRVTILEVWQADIRFTSWSPDRYE-TLVITRIQIQRGQ-HFEHKRQAKFALL---DRI-RATFLSREAEALICICCRELD-GQLAIDVAVVNAMGGDLAAVEVPLEVLFAMSVVASCAEGTPAMDRLLRTREFRS-VKPRALEGTMVFGLIADPVDLK-AALFGASVEGDVFDGGGHETMEKRPGNESKLNGELGYAAQVEQVTALPIQSVGDALPSIGLL-EV-LRHPYDAEKDEFVRDHYVLKGFDVKAIRKNETHEPLDAEELSVASEVEITEENMAEHAMIVPEITAEHDMAMSERGKVLTYAAPGPAKPLRYMVYRCAREFTKASYGEIITDNESPADEGEV-ETIGPGTPQEMGVHGIHPPYTGNLFRFYPVLITIVLRLQSVIR-GRLISPFPFEEDLPDKIPAGLTSELIVKRVVYVLYFGHFSGEGAVFVMRVLWVAEPMENLQVIRKLEGILGEAAIVAILVFSAVDKEILYVGNCAQTERITLVNVPHDPVWQIRIVAAIEERPAAFLEEAVEAGEHVQHVTGLGEFVEPAR-PIGLGPDPFVATTVSRAATLAGDTPVTVSMPGVRIVLAADVREHPISYSLKAPPTTFVLFSKRLAGEFREIDGLPSRAGTQNCSGTIAATYRVGGAEFPIV----ICFV-LSIDYATPTGADILAGPEMNLVHPAGICIDEIDYIFEMLLQMRRTVIFADVFILSTPVGDVMAYLVMIHALHIIIFSDTMDGKIDVAIAALSFAGHAHMAIRDVLPSSAITVEVAVR-LPRLEDLHAI-LAVACDVGQVIEADGTTIFDPPPSKTAPLEVYGSREEYDACIVTNLFASHKAVSRDDTLAATEAKEDTKKDNTARRLDVAEGLVVKIRVNQVGDGAINIDEIGIRLSIVVDKLGDRGTQVFPKYISVQMERGYKIIVAAKYGAVAKLIKDRTGHDKFIVIIDKFIYSYPDAVVIVVSQAEAVCTNTKSYLLRATKKARLDLLLKRSRVEYDVHNVDTLLRGSQQFITHAIVSYRAPIGAEITDLKPDLPLVRVVVRFQAKSEIETIDKLDFTYTFETRFVAQMALELDREKLLAS--GDQMLIEIKVEHYLTRGSAGSVLFNRDELMSCQNMIVKERIEVQVATGTGIPSVTIGSSAEEASE-NAKNEVSHFRMTDKYVKKIPFVKRKPARYVYVKEGGTIVVEKRSTDEIVCDIEATKKVPTRKSTQKIDADRALRLMIQVIGEIHKIENYGIQRIRRIQK-DLHSMLAMAPLGSYRVITMLAAKIV------------------------------------------VIGLLASVALAVAIKYEG---FPHILYRAKRIKEGEADRTGLKQKQKAYNANHGAPLRNRRTVKVFEMCHVMAGPRPVQILKK-RRDKVKEMSDVIVQPHEIENHGRLFVIRGADSLDSVARIDGLGVTKLLLHVCPTRDGVDTGLEVRATDGEAAFRLIPHKKFYGQ------------------------------------------IVILIIAGLAGAAEFVIPASSVIKLLDITDVVKIGDDEVVAF--RAIGAVASSSEWRVRVAFSMNHASPSARCLYGIVADVGIITGEIGDDKKKLFGAIQMLAIRARLRFTSSLVIIGTKVAEFELVAILEARLPAVKDVALRGNPRVVRLGRFPLRGASLKKTTSEVIKQAQMQQLAQERAVLADDAVVSMKLRTLREKQKAFQLAQRATQIMMMATDDAWIAEGRKIYEVIDLVSNAITNLETIVDGIPLKVAAHKFDALAQEPETEWMRPVLNLDISRDTEGTDGKVTTRVLPILQMTNTVVSRPHPIPEPERELPLGLQGVGIYALSAEMSA---YVHKRATYTLEIADGTSDQAVGVGKKMYQEFVRGPKIT-NRILPRPGTLMKLVNDAAVGEVARIENDIKALATVSQKEKHAKGHIFATIVLTSVNESQMIQAKHVKAPKQRSAAAAAMRISRGIKFVTKIPTRTITAVDAESVEAAVMRKVYGTDDMRMSERKTRFVKATEGESKLIVQNATIKLEFEQVAVTMTMKIVFKAEEILLVSGFPIGVVTMERVEKVYQNIEKGTVLNETLKGNANIEARERLSSTEEGEEGL-EASFSQLDSTRRASRDMTKTIIDQIQPVDRINDVGVAAVLLHGQDIAIGRYNKIASIIEIMGLARYSLKRTREIRIEAAIAWVDIDVVVYPEAPPALTPDPLFCGFEMNKPYRIALIDYLPNAWGVKAAGRAPIKASD-FGAAGRVPLRNNTTALERTGRVCVVDRHGRRGIVATSDKVKRNRSEMLNGTEIKVIFATAWHLSDGSLFVRDWQGPQATFVEQEGVFGG-DYLLSGDAKTDYVKEAIRVSVNLVSEPCQPFVYSKQDIESVKKLVEIAKQIAAGTVDEYAPTAGLMDEKQPREIDSIRGIRREISILLVEEGIGLDF-EFHWIYILASEQ-AGSIVPVDVHALKRVVTLEEKMR-TSEDEDTIDLATLVIPVSRVPDVCLHPVVEERPAAMEKSVHDLWSFDLYHKVERATALCVVWGVGFHPLRYVEPLAQMERALGAGL
+>UBA8339
+RKTARIVFKACFMLAILLATALVGAFVTVAHMAKQAINSTGH------------------------------------------DVDLHSLLSGLVIGAMMRSTMIQVARIAERGNY---------SFTLKNRRAAKGFSPKKAQEPHLRYKLVSHDAAVVENVSTSPVYQEPNCRQIIVRGIPSKQAFEVVYFMIHIINGGAAHKKGKL---------------------------MNLDNIYNTGDKLPI-----NVDHIIQEEKCPCVYTLAPATSVFDIHQLQLYVLRGW------------------------------------------TDIDFLMAQDGYVTAVRRQNQVVTAGDVPNPVSHAQ-----------GSYHAKIDGGLEISDKTMRRLQSVTVRPRFMQDIVKT-----------------------MPRTIEKQAWANVARPRP-AVVHQELVGEA-SPSDQLIEAPVVQGWADRLVQSPSGTAYLIIIVSSVIAHKWEEYKQLVDGTESEAMAVGLKRMYVGHLDLEE-ILWIRKRAPRMQIRVIRHLKVRYIPEVNEHIRINVRLCRDE---PAEVVEIRMTTQVKVRVNAPNGIISVVPIRILMKDGRRLLTEGGREPRLGAAHLDKRQGLLFVQAGFAQLAGSGVELGRFV------------------------------------------AHKTSRVIDAHSPLIVCTFQPLTLYIASEMAVPYIAHEAR-------------------------------------------------------------------------------------------EARHLVLALLVILFFGAMISRWVRKISAKIATEDEEALLFAFMGGVGNSGAFFGFLGSLKSSATFAIMFSLALVPILYPVKMVLVELVHDVLEAAVSLIVLYDERSATFGEPLRKATIELG--SWRITSDSTLAGRIVIDTRLLH--VVSITFVDSQAVPDHR---------------------------------------------------------LLNNVGIVDVSRRLASVTLITEEDTLDLQAAAMLSCYMIHPVHPDGGACLESQVAMAAIVLNA------------------------------------------------RLYQKWAHAEWRVSFELRTKVEHAELMDVKAVNSEIDEIVQV------------------------------------------VLEIKIVIQ-AKALRASVLFLSMLLSVFSYVAVQ-YPGNNP------ATECRLAEIYIGTLSMEGVEPLDVVMKLAIELVED--------------------------------------------ELRIESAQVLRLNHSDYFPPEDDPEFYIT-------------------------------------------------------ACLELETTLIDPILVAVADQLFLPFTLCVMDMLNPLLVVNNV------------------------------------------FLAGLEPVPVLVAFVESYEQLFALDRLIYITKFGVLRALDM--WVLEADRGQADGVMVTVEICSDKIVKVSLQQIDATAATGED-DVLIQMEQMWFDHHVDDVSLLELGAFEG-HRTVGDHDQLA-TSSPLTEVDDHLRIIIAVQMKHAAQERADPQEL-HEGVQEAD-NIGQMVEGIKSKGIINENRLASATEEENVVRTSNITHPL---------------------------------------------AVRTA-GKPRMRKFRISRWQLATVSGK-TKRLNLSNNGG--AAYVRFVGFRADITSNSGAIFTGSQRCRGQSVPARKMPVRGE------------------------------------------DLGRKDAHERPASTRVEKSDYKEKDIALLSER-AGSKDEGQ-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ASRHFVGELNRTLGGTIA-AGVGGGDVITTSSIRKSIEGSTD------------------------------------------------------------------------------------LMVELIFFHFFQLMMLMDGILRADCAAKAVAF-EAVKSVDPD------------------------------------------PRVGWSVYENSLNSETWPADGVAFILFYVPEIALMPTRFT--VKTARVDMGISLPRVLRSGAPDLKAGTRVSSKEVSMELIPVRYVKVKEKNTFSHKLTYAEIIVDLEHVGVC-APKITCL-----------------------------------------------DLDALLDGTAIDETTSAVFCIAPRQLDKGKVPVDLA------------------------------------------------------------------------------------------VETRPGREKSKTGRIGQAVQVEAVNAIPIREIGSSPPSIGLK-EL-LRNKYEAADDSFVGNHCVLRGFDAHGTRKREVNQYFEA------------------------------------------VAKAGGEKPFRTVIFRANRDFVKTQHGQLIKDPENSLDE-SI------------------------------------------------------------------------------------SGQGCIFVMRTYTVAIEMEEVQVIEQIEGILAEVAVAGMLIFAAVDGEIFWVGNAAEEDVFTLVEVPKDSVWAVRLVAAVEEKH------------------------------------------VGESADNAGHGPLMMDLPVTSIWSNADVKDAEILWLSKALEDLLVMGTEKYADEMQELASLPARDGCSNTTDTLAETLLVTGAKFPIL-L--HMLLMIAMHGSLPSGAL-VGGYAMNLVSPE-LCMHDIWPIYEILLNIKGTMYLAAAHMLCLPVSGIMAYVFMIWAL-LIMLEEPLGGDVGVTVIAYQAGGHAIMTIDDVVAGAVITARIGCPALGKLQDGFAILHIAACDVTQIMEADGNPKSQIDEGATDPLTVSGSHEDYDTTVVASMYCDHKTCSRQEEMRAAEAKSDT------------------------------------------RKTGDRGTEVHPRFLNLKMERGYRAIVASKHGSVAKLIEGREANDRFIVLIDRLLFPYPEAVAILFQQAEAVVANLKAYLLRTE------------------------------------------------------------------------------------FMENMPMYIGREHFLNRS--ATLVIAIQVEHYLTRSGPGSVLFGKDTLVTGAKLVVKGKADLQVCAAIAVPALVLGTKCNESGENRARTNMHHAKKAEVYLAAVPFVRKGGPRFVIAEQGITVFLD--TENQIVASITCGRRVPVRKATEKLDKDTALRVTIPIVSEIHKIRSFGIQTLDECRKFDKHNLLAFNPSQPFRVLTKMAEKIL-----------------LPEGILDMLGYGALFQAETLMSTLVVFGLLASSALIAAIRYEN-RKFPMVLYSRRNLRHGQQSRRGLMKKQKAFNAMHRAKDAGRTVVVVQTSGEVKANAVVVVVESRLARERQKSLLDLLVDARQLEEHGRLFVIRGEIRIEMEGA-----------------------------------------------------------------------------------------VVLIIADIQLVPQLVTPGAVVVRLGAIGEVVKAGDDRLDPF------------------------------------------TDLLGNARRQLFGAIQMAHPRARLKITSALVAIAARIADYTL------------------------------------------------------------------------------------------------------------------------------------------------------------------------RVSARKLDQVIA-DRGVPAAARDL-DALAAFGVIPVSAGVN-------------------------------------------ERVVARPQPLRKLANSISTGDIARLHGDLRELRSVPRKEKLR------------------------------------------------------------------------------------------------------------------------------------------------------------------------IKATAKGESGVPYLKMARLDGSRRQIRQLDSTLVSGIGEVERINDIGIAAVLLHPQDMGIARFVGLMHYVEVMGMGKHSIKVAR------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ETTDRGSLVAGLMDEHQPRDVKSVEGIGKEVSMLCISNGIGI------WLYILRAADLGGSMVPTKLGALDAEDPLEEETRGGD------------------------------------------SVNALHSAKRAAVMCVIQGVGFFPLAGVRPLARMDRTCITRT
+>GB_GCA_002412085.1
+------------------------------------------------------MIKGINDVRGGIENHNDKEFISNKTKINLYKSELQNRIKYVLMGSFMKDKAFIYTVSAKKNDIMLLFELS--SVVNKSIVVINFILKDKREESIQAKKEVPSEEVVILGIHATK--KQPMTRQYVVKDPPSKEAFKVLWFLV--------------DNYFLVWLSGKGKKEKDSLIKVMSKGNLFTDNIVQINDSLKIVTIYNSSDAIII----GGFLKLEPAVDVVPAIEIELETWNGF--YNENLIKTSSEASRMSLKINYIIIENKEFLGNLKPVERM--DVILLLEEESFVTGARRQNY---------------------KFVNKGSVKAKLDLGGVISYMTMSNFKKIGL-KRLTQFIIK--HRKLINEIIKALSFDKVIPDSRLPAVVLNKAYEGIVLPKR-IRSQYKIMQKEDKLLEEYVKDPAVKNAEGDIIKSATGYYYVVMIMSKPLSQYWEKYKEEIKEPIKEVLNLGIKAIFLGTID---QTMEVPKKAAAAKLRIKRHLKATKIQDVNNEIRMNIRMCKD-MAYPSEVIEIRVATQVRCKVLGDKDIIRVRPVVILMKEEMMI------------------------------------------AGGRLPKATRADKDKKVQSRAHKGGIRSFWRLDSKIKHSMRY-------------TILISYKNEAIHLKDKAMVPYIKNGINKE-------------------------------------------DFKRSTTKGKFKSNSKGMPFVLDVL-EISSVRKEKCKIAVI-NLIKDRYNILIGLMLVLMFKKNLVKNLKCALIKTVRKMS-----------------------------------------------------------------------------------------LYVLR------MIVIDTRLKGIKVIRFIVMYKSKIS---------KLQKQEVLFTEEGNIKYPEDEIQATGLDLAISQKIFIVFGESLQAIDIAGNLIKGYNLAEANNSITSVLLISKEMNE-----------------------------------------------------IKIEGSSKTDREIKFHLETSINIASSVELEKT-YNIDKNYGKKINIFKVFEELNRIDAIQVKAIAPDLKSVLKHVTTNGNAIFIEVNKKITAISAALIASKTLIAGKININEHLMK----------------N-FILNFIRELLKPVEAS-YPN----EYGDD--TLLVKVVYIGDPDTEEIDSVGVKIEFVSKSMGGY-KLEIKYYFYEINGELEEALLDV--TIQILKLK---GIYKSI-SIKVGTVNIIKADVGSFVMPLKSSIFVMEK-NDKLKVTSAKQ-------------------------------------------------------------------------------------INEILDCKTDLLPRVVGRVMSIERAGADMYVDIEIGVSLLKYFKK--LAIIYLAYLEKWTKKALYNKK-WIGIFAMRIAVKKLVTVLEEKSFIGEIFLIAPKVIKKAEINIALQDEDNSSITGDD------------------------------------------SCEDITKTDNETKLMIKIDI-----------------------------------------------------------------------------------------------------------AFEIVYGKESL-NFIIKSLVIKSPKGKMRKRFRLNKIDGEI-GYAKYSKFVSELNANKNHVYTGSSQKRGTEVNAFKKGV----------------------------------------------LGRRSLKEVANETKSQNLEHKEDELLLIKGDAVLK-DSGKH--EIRRYVADL--NFGMELISGKSKKDEDSEVISILLEANKL--TKKGKGRRKKLFLGEKRNKILNGKIRRRRNKAIEDAVDV-V-LLS-ILSYPAACTYLIKSHPIDFT--S-KDNNQEFIK---------------------------------------------LESLELYKDKKEKQRWRVFSDTAFAAWILCHAMNHRKLGADV------------------------------------------------------------------------------------VILFFTIVRFFLI-ERIKTSKVVKVIANLTTVMDQFLGWFPFAVFKLMAKLKNIKFRLNLAPMTMGETKSMENKFVDRDNVSDDFLGQLIYFTSLNQQVIVDALIRAEI-------I-EFESVESNKAFWIDRNGKIELETSI-MEISKLSDIPFGSKNLFYVFIIQPYRVGYNVFCET---ELRKDKSVALVWMYKT-VAIFDVEILEVVRVTQAELRISIYKILNIGLSELKQGSTVNEKELTVMFVPVSYVKVENKTDYSYRLMWVQYIVRENYVLAIKNPKIIIMDKWPA-----------------------------------------------------EEHTKHYSVIIGRDLDVKNIPVDVSPISDMG------------------------------------------------------------------------------------IRKRDGEVRDDSDEIAYAIHTRQVSAIPTRSAGDAT--VGL-------------------------------------------SNLASIKEREIHDTAMAEHYMIVPGIKGEDSMRLTSEGDVLTAAKAGNIEYWLLNFFDAEREFTKTTVGRVYSEKIS-TDSP--IDK-KKGLIEDINYFSINKPFTNTIIRLYPSNVLIMLGIDTL---SNLVEPFPYEGKIPDSITSGFTTKAKALKVELKLYFYHF------------------------------------------TVVENEILYITQASQENKSNIIEIEI-KVFNFEILAAILE--ITKLEMALQIEKGMEAIGGLERVVDNGEEMAELGNEDMVFDT---------------------------------------------MYPRSIRIKIEFIDKLPAEQNVSITSNEIKNTL-II---------------------------------------------------------------------------------------------------------------------------------IAVIIFGKLYSLDAVNLVISPSSKELIEAEGDPVFNIPESST------------------------------------------LMRVNRSYSWRNAALVLKKKVNVVWSKGVSVDIVRIAQALKI------------------------------------------GRARFVRIIDKFLYKSAKLMNFLLRRADAKATNTKGLLAD-KRKRKIRLLLNRLRVNGKITDIDTFLNESEQIITHTVSSYMDPTEQEIKDLLPDLPL-SMVVGIKAKSEFKTIDKLDTTVTFALRYIDKMSNDLKRKLFLSK--ASPLVIHVKLSHRLSTGSPKSVIFDKSVLFTSQRMIVHKNLDIQVESAVGQAQVLIG-DAEIASI------------------------------------------KRTTDELVCNIESLKKKTTRRASEKIQADKALHIMTAVVNEM--ISKYGIQMINRLEEYNKEEVIALRQPRPYKILTKLAYSLT------------------------------------------IIDALATAALNAIVKYRG---FTGVIDHEKRVKEGAKDKEA-VSKQKYNNAIHKVKLRKRNFIKVFETLDAKNGPFPLIILAGI------------------------------------------SIKNLLLKLCNSKSGIDTGIS----DNACSLNLINHKEFYGEFDIILMIGVVNQQIRNGMIIEVKLENGN---KSNKQRIVSIN-VILFIGGVKNY-DLLYPGSSEVRLYGLKIILKCKNDKLKEI--DIIASIGPEDDWKANSAFTTNLGEPFRRVLITETFDAGMIIQIIGGEKKQIYGAIQLAKPNGRLKIMAALIVIGVSVAEFTITAILKVYLEELVEFFIKKPNKVVK-GQFPLPFDKIFNDK-------ELRQLQTEKTLVDKHSLFQLKIKIFRSKSDEISMDK-----LLFAFSEANIIDTYGIVNVVGLVINLITELEPLSDYVVVKTSRFKFSFVSEDKETDYLSLIEGLDVTVDNKE-NGKVSLA-FHVMRRLDNIVYKPANVKDRDKKMPFKLKKF-IYVTLIENQ--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------FVIKVFI--FDIEIVCYGNCP-KTTRDSYIESIQSVI-FRK------------------------------------------------------------------------------------KMFITDSTFYVKRAYGPQSYFEEKVATYGP-DNLMCKGS---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
diff --git a/tests/data/example.faa.gz b/tests/data/example.faa.gz
new file mode 100644
index 00000000..81ba2e0c
Binary files /dev/null and b/tests/data/example.faa.gz differ
diff --git a/tests/test_classify.py b/tests/test_classify.py
index 00e0fedf..41c99c2f 100644
--- a/tests/test_classify.py
+++ b/tests/test_classify.py
@@ -26,7 +26,7 @@
 from gtdbtk.biolib_lite.taxonomy import Taxonomy
 from gtdbtk.classify import Classify
 from gtdbtk.config.output import *
-from gtdbtk.io.pplacer_classification import PplacerClassifyFileAR122
+from gtdbtk.io.pplacer_classification import PplacerClassifyFileAR53
 
 
 class TestClassify(unittest.TestCase):
@@ -37,7 +37,7 @@ def setUp(self):
         self.prefix = 'gtdbtk'
         self.pplacer_dir_reference = 'tests/data/pplacer_dir_reference'
         self.aln_dir_ref = 'tests/data/align_dir_reference/align'
-        self.user_msa_file = os.path.join(self.aln_dir_ref, 'gtdbtk.ar122.user_msa.fasta')
+        self.user_msa_file = os.path.join(self.aln_dir_ref, 'gtdbtk.ar53.user_msa.fasta')
         self.taxonomy_file = Config.TAXONOMY_FILE
         self.gtdb_taxonomy = Taxonomy().read(self.taxonomy_file)
 
@@ -55,14 +55,14 @@ def test_standardise_taxonomy(self):
         # Test that the correct domain is returned.
         self.assertEqual(self.classify.standardise_taxonomy('p__P;c__C;o__O;f__F;g__G;s__S', 'bac120'),
                          'd__Bacteria;p__P;c__C;o__O;f__F;g__G;s__S')
-        self.assertEqual(self.classify.standardise_taxonomy('p__P;c__C;o__O;f__F;g__G;s__S', 'ar122'),
+        self.assertEqual(self.classify.standardise_taxonomy('p__P;c__C;o__O;f__F;g__G;s__S', 'ar53'),
                          'd__Archaea;p__P;c__C;o__O;f__F;g__G;s__S')
 
         # Remove ranks and check
         rank_order = {'p': 0, 'c': 1, 'o': 2, 'f': 3, 'g': 4, 's': 5}
         rank_lst = ['p__P', 'c__C', 'o__O', 'f__F', 'g__G', 's__S']
         ranks = {'p': 'P', 'c': 'C', 'o': 'O', 'f': 'F', 'g': 'G', 's': 'S'}
-        dom_info = {'d__Bacteria': 'bac120', 'd__Archaea': 'ar122'}
+        dom_info = {'d__Bacteria': 'bac120', 'd__Archaea': 'ar53'}
 
         for k in range(1, len(ranks) - 1):
             for cur_domain in ('d__Bacteria', 'd__Archaea'):
@@ -87,15 +87,15 @@ def test_get_pplacer_taxonomy(self):
         if not os.path.exists(self.out_dir):
             os.makedirs(self.out_dir)
         tree = dendropy.Tree.get_from_path(os.path.join(os.getcwd(), self.pplacer_dir_reference,
-                                                        'gtdbtk.ar122.classify.tree'),
+                                                        'gtdbtk.ar53.classify.tree'),
                                            schema='newick',
                                            rooting='force-rooted',
                                            preserve_underscores=True)
-        pplacer_classify_file = PplacerClassifyFileAR122(self.out_dir, self.prefix)
-        self.classify._get_pplacer_taxonomy(pplacer_classify_file, 'ar122', self.user_msa_file, tree)
+        pplacer_classify_file = PplacerClassifyFileAR53(self.out_dir, self.prefix)
+        self.classify._get_pplacer_taxonomy(pplacer_classify_file, 'ar53', self.user_msa_file, tree)
         results = {}
 
-        with open(os.path.join(self.out_dir, PATH_AR122_PPLACER_CLASS.format(prefix=self.prefix)), 'r') as f:
+        with open(os.path.join(self.out_dir, PATH_AR53_PPLACER_CLASS.format(prefix=self.prefix)), 'r') as f:
             for line in f:
                 infos = line.strip().split('\t')
                 results[infos[0]] = infos[1]
@@ -108,7 +108,7 @@ def test_get_pplacer_taxonomy(self):
 
     def test_place_genomes(self):
         tree_file = self.classify.place_genomes(
-            self.user_msa_file, 'ar122', self.out_dir, self.prefix)
+            self.user_msa_file, 'ar53', self.out_dir, self.prefix)
         with open(tree_file, 'r') as f:
             lines = f.read().splitlines()
             last_line = lines[-1]
@@ -128,7 +128,7 @@ def test_formatnote(self):
 
     def test_calculate_red_distances(self):
         tree = os.path.join(self.pplacer_dir_reference,
-                            'gtdbtk.ar122.classify.tree')
+                            'gtdbtk.ar53.classify.tree')
         result_tree = self.classify._calculate_red_distances(
             tree, self.out_dir)
         egs2 = [eg.length for eg in result_tree.postorder_edge_iter()
diff --git a/tests/test_cli.py b/tests/test_cli.py
index d2c0c426..a5df3c98 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -89,15 +89,15 @@ def test_identify(self):
             self.generic_out_path, tmp_folder, 'identify')
         self.optionparser.identify(identify_options)
 
-        ar122_marker_path = os.path.join(self.options.out_dir,
-                                         PATH_AR122_MARKER_SUMMARY.format(prefix=self.options.prefix))
+        ar53_marker_path = os.path.join(self.options.out_dir,
+                                         PATH_AR53_MARKER_SUMMARY.format(prefix=self.options.prefix))
 
         self.assertTrue(os.path.isfile(
             os.path.join(self.options.out_dir, PATH_BAC120_MARKER_SUMMARY.format(prefix=self.options.prefix))))
-        self.assertTrue(os.path.isfile(ar122_marker_path))
+        self.assertTrue(os.path.isfile(ar53_marker_path))
 
         results = {}
-        with open(ar122_marker_path, 'r') as f:
+        with open(ar53_marker_path, 'r') as f:
             f.readline()
             for line in f:
                 infos = line.split('\t', 1)
@@ -112,7 +112,7 @@ def test_align(self):
         align_options.out_dir = os.path.join(
             self.generic_out_path, tmp_folder, 'align')
         self.optionparser.align(align_options)
-        path_user_msa = os.path.join(align_options.out_dir, PATH_AR122_USER_MSA.format(prefix=align_options.prefix))
+        path_user_msa = os.path.join(align_options.out_dir, PATH_AR53_USER_MSA.format(prefix=align_options.prefix))
         self.assertTrue(os.path.isfile(path_user_msa))
         with open(path_user_msa, 'r') as f:
             lines = f.read().splitlines()
@@ -138,7 +138,7 @@ def test_identify_align(self):
         align_options.out_dir = os.path.join(
             self.generic_out_path, tmp_folder, 'align')
         self.optionparser.align(align_options)
-        path_user_msa = os.path.join(align_options.out_dir, PATH_AR122_USER_MSA.format(prefix=align_options.prefix))
+        path_user_msa = os.path.join(align_options.out_dir, PATH_AR53_USER_MSA.format(prefix=align_options.prefix))
         self.assertTrue(os.path.isfile(path_user_msa))
         with open(path_user_msa, 'r') as f:
             lines = f.read().splitlines()
@@ -164,7 +164,7 @@ def test_identify_align_classify(self):
         align_options.out_dir = os.path.join(
             self.generic_out_path, tmp_folder, 'align')
         self.optionparser.align(align_options)
-        path_user_msa = os.path.join(align_options.out_dir, PATH_AR122_USER_MSA.format(prefix=align_options.prefix))
+        path_user_msa = os.path.join(align_options.out_dir, PATH_AR53_USER_MSA.format(prefix=align_options.prefix))
         self.assertTrue(os.path.isfile(path_user_msa))
         with open(path_user_msa, 'r') as f:
             lines = f.read().splitlines()
@@ -176,14 +176,14 @@ def test_identify_align_classify(self):
 
         classify_options = self.options
         classify_options.genome_dir = self.genome_dir
-        classify_options.split_tree = False
+        classify_options.full_tree = True
         classify_options.align_dir = align_options.out_dir
         classify_options.out_dir = os.path.join(
             self.generic_out_path, tmp_folder, 'classify')
         classify_options.recalculate_red = False
         self.optionparser.classify(classify_options)
         summary_out = os.path.join(classify_options.out_dir,
-                                   PATH_AR122_SUMMARY_OUT.format(prefix=classify_options.prefix))
+                                   PATH_AR53_SUMMARY_OUT.format(prefix=classify_options.prefix))
         self.assertTrue(summary_out)
         with open(summary_out, 'r') as f:
             lines = f.read().splitlines()
@@ -192,6 +192,15 @@ def test_identify_align_classify(self):
         self.assertEqual(len(infos), 20)
         self.assertTrue(infos[1].startswith('d__Archaea'))
 
+        self.assertTrue(os.path.isdir(os.path.join(classify_options.out_dir, DIR_IDENTIFY_INTERMEDIATE)))
+        self.assertTrue(os.path.isdir(os.path.join(classify_options.out_dir, DIR_ALIGN_INTERMEDIATE)))
+        self.assertTrue(os.path.isdir(os.path.join(classify_options.out_dir, DIR_CLASSIFY_INTERMEDIATE)))
+        self.optionparser.remove_intermediate_files(classify_options.out_dir,'classify_wf')
+        self.assertFalse(os.path.exists(os.path.join(classify_options.out_dir, DIR_IDENTIFY_INTERMEDIATE)))
+        self.assertFalse(os.path.exists(os.path.join(classify_options.out_dir, DIR_ALIGN_INTERMEDIATE)))
+        self.assertFalse(os.path.exists(os.path.join(classify_options.out_dir, DIR_CLASSIFY_INTERMEDIATE)))
+
+
     def test_classify_wf(self):
         tmp_folder = ''.join(random.choice(
             string.ascii_uppercase + string.digits) for _ in range(10))
@@ -210,11 +219,11 @@ def test_classify_wf(self):
         classify_wf_options.cols_per_gene = None
         classify_wf_options.max_consensus = None
         classify_wf_options.recalculate_red = False
-        classify_wf_options.split_tree = False
+        classify_wf_options.full_tree = True
         self.optionparser.align(classify_wf_options)
         self.optionparser.classify(classify_wf_options)
         summary_out = os.path.join(classify_wf_options.out_dir,
-                                   PATH_AR122_SUMMARY_OUT.format(prefix=classify_wf_options.prefix))
+                                   PATH_AR53_SUMMARY_OUT.format(prefix=classify_wf_options.prefix))
         self.assertTrue(os.path.isfile(summary_out))
         with open(summary_out, 'r') as f:
             lines = f.read().splitlines()
@@ -227,7 +236,7 @@ def test_infer(self):
         tmp_folder = ''.join(random.choice(
             string.ascii_uppercase + string.digits) for _ in range(10))
         infer_options = self.options
-        path_user_msa = PATH_AR122_USER_MSA.format(prefix=self.options.prefix)
+        path_user_msa = PATH_AR53_USER_MSA.format(prefix=self.options.prefix)
         infer_options.msa_file = os.path.join(self.align_dir_reference, path_user_msa)
         infer_options.out_dir = os.path.join(self.generic_out_path, tmp_folder, 'infer')
         infer_options.gamma = False
@@ -250,7 +259,7 @@ def test_de_novo_wf(self):
             string.ascii_uppercase + string.digits) for _ in range(10))
         de_novo_wf_options = self.options
         de_novo_wf_options.genome_dir = self.genome_dir
-        de_novo_wf_options.suffix = ".ar122"
+        de_novo_wf_options.suffix = ".ar53"
         de_novo_wf_options.gamma = False
         de_novo_wf_options.out_dir = os.path.join(
             self.generic_out_path, tmp_folder, 'de_novo_wf')
@@ -264,8 +273,8 @@ def test_de_novo_wf(self):
     def test_root(self):
         """Test that rooting is successful when called through the CLI"""
         options = argparse.ArgumentParser()
-        options.input_tree = 'tests/data/pplacer_dir_reference/gtdbtk.ar122.classify.tree'
-        options.outgroup_taxon = 'p__Altarchaeota'
+        options.input_tree = 'tests/data/pplacer_dir_reference/gtdbtk.ar53.classify.tree'
+        options.outgroup_taxon = 'p__Altiarchaeota'
         options.output_tree = os.path.join(self.generic_out_path, 'test.rooted.tree')
         options.custom_taxonomy_file = None
         options.gtdbtk_classification_file = None
diff --git a/tests/test_gtdbtk/test__main__.py b/tests/test_gtdbtk/test__main__.py
index 844ac7bf..cdf543d1 100644
--- a/tests/test_gtdbtk/test__main__.py
+++ b/tests/test_gtdbtk/test__main__.py
@@ -20,8 +20,8 @@
 import tempfile
 import unittest
 
-from gtdbtk.config.config import CONCAT_AR122, CONCAT_BAC120, MASK_AR122, MASK_DIR, MASK_BAC120
-from gtdbtk.io.classify_summary import ClassifySummaryFileAR122
+from gtdbtk.config.config import CONCAT_AR53, CONCAT_BAC120, MASK_AR53, MASK_DIR, MASK_BAC120
+from gtdbtk.io.classify_summary import ClassifySummaryFileAR53
 from gtdbtk.tools import sha256
 
 
@@ -48,7 +48,7 @@ def test_classify_wf(self):
         p.wait()
         self.assertEqual(p.returncode, 0)
 
-        classify_file = ClassifySummaryFileAR122(out_dir=self.dir_tmp, prefix='gtdbtk')
+        classify_file = ClassifySummaryFileAR53(out_dir=self.dir_tmp, prefix='gtdbtk')
         classify_file.read()
 
         expected = {
@@ -131,7 +131,7 @@ def test_decorate(self):
         stdout, stderr = proc.communicate()
         self.assertEqual(proc.returncode, 0)
 
-        msa_file = os.path.join(align_dir, 'align', 'gtdbtk.ar122.msa.fasta')
+        msa_file = os.path.join(align_dir, 'align', 'gtdbtk.ar53.msa.fasta')
         infer_dir = os.path.join(self.dir_tmp, 'infer')
         args = ['python', '-m', 'gtdbtk', 'infer', '--msa_file',
                 msa_file, '--out_dir', infer_dir, '--cpus', self.cpus]
@@ -176,14 +176,14 @@ def test_ani_rep(self):
 
     def test_trim_msa(self):
         path_out = os.path.join(self.dir_tmp, 'msa.faa')
-        args = ['python', '-m', 'gtdbtk', 'trim_msa', '--untrimmed_msa', CONCAT_AR122,
+        args = ['python', '-m', 'gtdbtk', 'trim_msa', '--untrimmed_msa', CONCAT_AR53,
                 '--output', path_out, '--reference_mask', 'arc']
         proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding='utf-8')
         stdout, stderr = proc.communicate()
         self.assertEqual(proc.returncode, 0)
 
     def test_trim_msa_reference_mask_arc(self):
-        with open(os.path.join(MASK_DIR, MASK_AR122), 'r') as f:
+        with open(os.path.join(MASK_DIR, MASK_AR53), 'r') as f:
             mask = [x == '1' for x in f.read().strip()]
 
         path_untrimmed_msa = os.path.join(self.dir_tmp, 'untrimmed_msa.fasta')
@@ -290,7 +290,7 @@ def test_export_msa_arc(self):
         self.assertEqual(p.returncode, 0)
 
         test_hash = sha256(path_output)
-        true_hash = sha256(CONCAT_AR122)
+        true_hash = sha256(CONCAT_AR53)
         self.assertEqual(test_hash, true_hash)
 
     def test_export_msa_bac(self):
diff --git a/tests/test_gtdbtk/test_external/test_fasttree.py b/tests/test_gtdbtk/test_external/test_fasttree.py
new file mode 100644
index 00000000..cf6f723d
--- /dev/null
+++ b/tests/test_gtdbtk/test_external/test_fasttree.py
@@ -0,0 +1,62 @@
+###############################################################################
+#                                                                             #
+#    This program is free software: you can redistribute it and/or modify     #
+#    it under the terms of the GNU General Public License as published by     #
+#    the Free Software Foundation, either version 3 of the License, or        #
+#    (at your option) any later version.                                      #
+#                                                                             #
+#    This program is distributed in the hope that it will be useful,          #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of           #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
+#    GNU General Public License for more details.                             #
+#                                                                             #
+#    You should have received a copy of the GNU General Public License        #
+#    along with this program. If not, see <http://www.gnu.org/licenses/>.     #
+#                                                                             #
+###############################################################################
+import os
+import shutil
+import tempfile
+import unittest
+
+import gtdbtk.config.config as Config
+from gtdbtk.external.fasttree import FastTree
+
+
+class TestFastTree(unittest.TestCase):
+
+    def setUp(self):
+        self.dir_tmp = tempfile.mkdtemp(prefix='gtdbtk_tmp_')
+        self.cpus = 1
+        self.genome_root = Config.FASTANI_GENOMES
+        self.test_msa = 'tests/data/example.faa'
+        self.test_msa_gz = 'tests/data/example.faa.gz'
+
+    def tearDown(self):
+        shutil.rmtree(self.dir_tmp)
+
+    def test_run(self):
+        ft = FastTree()
+        output_tree = os.path.join(self.dir_tmp, 'output.tree')
+        tree_log = os.path.join(self.dir_tmp, 'tree.log')
+        fasttree_log = os.path.join(self.dir_tmp, 'fasttree.log')
+        prot_model = 'WAG'
+        no_support = False
+        gamma = False
+        msa_file = self.test_msa
+        cpus = self.cpus
+        ft.run(output_tree, tree_log, fasttree_log, prot_model, no_support, gamma, msa_file, cpus)
+        self.assertTrue(os.path.isfile(output_tree))
+
+    def test_run_gzip(self):
+        ft = FastTree()
+        output_tree = os.path.join(self.dir_tmp, 'output.tree')
+        tree_log = os.path.join(self.dir_tmp, 'tree.log')
+        fasttree_log = os.path.join(self.dir_tmp, 'fasttree.log')
+        prot_model = 'WAG'
+        no_support = False
+        gamma = False
+        msa_file = self.test_msa_gz
+        cpus = self.cpus
+        ft.run(output_tree, tree_log, fasttree_log, prot_model, no_support, gamma, msa_file, cpus)
+        self.assertTrue(os.path.isfile(output_tree))
diff --git a/tests/test_gtdbtk/test_io/test_marker/test_copy_number.py b/tests/test_gtdbtk/test_io/test_marker/test_copy_number.py
index a205198a..ed1d42f3 100644
--- a/tests/test_gtdbtk/test_io/test_marker/test_copy_number.py
+++ b/tests/test_gtdbtk/test_io/test_marker/test_copy_number.py
@@ -20,8 +20,8 @@
 import tempfile
 import unittest
 
-from gtdbtk.config.output import PATH_BAC120_MARKER_SUMMARY, PATH_AR122_MARKER_SUMMARY
-from gtdbtk.io.marker.copy_number import CopyNumberFile, CopyNumberFileAR122, CopyNumberFileBAC120
+from gtdbtk.config.output import PATH_BAC120_MARKER_SUMMARY, PATH_AR53_MARKER_SUMMARY
+from gtdbtk.io.marker.copy_number import CopyNumberFile, CopyNumberFileAR53, CopyNumberFileBAC120
 from gtdbtk.io.marker.tophit import TopHitPfamFile, TopHitTigrFile, Hit
 
 
@@ -195,22 +195,22 @@ def test_read(self):
         self.assertDictEqual(genome_2_truth, test_cn.genomes['genome_2'])
 
 
-class TestCopyNumberFileAR122(unittest.TestCase):
+class TestCopyNumberFileAR53(unittest.TestCase):
 
     def setUp(self):
         self.dir_tmp = tempfile.mkdtemp(prefix='gtdbtk_tmp_')
-        self.cn = CopyNumberFileAR122(self.dir_tmp, 'tst')
+        self.cn = CopyNumberFileAR53(self.dir_tmp, 'tst')
 
     def tearDown(self):
         self.cn = None
         shutil.rmtree(self.dir_tmp)
 
     def test___init__(self):
-        path = os.path.join(self.dir_tmp, PATH_AR122_MARKER_SUMMARY.format(prefix='tst'))
+        path = os.path.join(self.dir_tmp, PATH_AR53_MARKER_SUMMARY.format(prefix='tst'))
         self.assertEqual(path, self.cn.path)
-        self.assertEqual('ar122', self.cn.marker_set)
+        self.assertEqual('ar53', self.cn.marker_set)
         self.assertDictEqual({}, self.cn.genomes)
-        self.assertEqual(122, len(self.cn.marker_names))
+        self.assertEqual(53, len(self.cn.marker_names))
 
 
 class TestCopyNumberFileBAC120(unittest.TestCase):