Repository: cogent3/cogent3
Pull request #1674 (2023-12-15 00:28:42)

Major refactor of sequence collection classes


Patch:
diff --git a/changelog.d/20231215_104826_Gavin.Huttley.md b/changelog.d/20231215_104826_Gavin.Huttley.md
new file mode 100644
index 000000000..facf1a998
--- /dev/null
+++ b/changelog.d/20231215_104826_Gavin.Huttley.md
@@ -0,0 +1,43 @@
+<!--
+A new scriv changelog fragment.
+
+Uncomment the section that is right (remove the HTML comment wrapper).
+-->
+
+<!--
+### Contributors
+
+- A bullet item for the Contributors category.
+
+-->
+<!--
+### ENH
+
+- A bullet item for the ENH category.
+
+-->
+<!--
+### BUG
+
+- A bullet item for the BUG category.
+
+-->
+<!--
+### DOC
+
+- A bullet item for the DOC category.
+
+-->
+<!--
+### Deprecations
+
+- A bullet item for the Deprecations category.
+
+-->
+
+### Discontinued
+
+- Began major refactor of the sequence collection classes. The major change
+  is they no longer accept fasta formatted string as input. As we have simplified
+  the data conversion functions, all previously used public functions have now been
+  marked as being discontinued 2024.3.
diff --git a/doc/cookbook/loading_sequences.rst b/doc/cookbook/loading_sequences.rst
index cf2851cfb..2cea78cda 100755
--- a/doc/cookbook/loading_sequences.rst
+++ b/doc/cookbook/loading_sequences.rst
@@ -13,7 +13,7 @@ It's also possible to load a sequence from a :ref:`url <load_url>`.
 .. jupyter-execute::
 
     from cogent3 import load_seq
-    
+
     seq = load_seq("data/mycoplasma-genitalium.fa", moltype="dna")
     seq
 
@@ -76,8 +76,10 @@ The ``cogent3`` load functions support loading from a url. We load the above fas
 
     from cogent3 import load_aligned_seqs
 
-
-    aln = load_aligned_seqs("https://raw.githubusercontent.com/cogent3/cogent3/develop/doc/data/long_testseqs.fasta", moltype="dna")
+    aln = load_aligned_seqs(
+        "https://raw.githubusercontent.com/cogent3/cogent3/develop/doc/data/long_testseqs.fasta",
+        moltype="dna",
+    )
 
 Specifying the file format
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -100,7 +102,7 @@ Simple case of loading a ``list`` of aligned amino acid sequences in FASTA forma
 
     from cogent3 import make_aligned_seqs
 
-    protein_seqs = [">seq1", "DEKQL-RG", ">seq2", "DDK--SRG"]
+    protein_seqs = {"seq1": "DEKQL-RG", "seq2": "DDK--SRG"}
     proteins_loaded = make_aligned_seqs(protein_seqs)
     proteins_loaded.moltype
     proteins_loaded
@@ -132,7 +134,7 @@ From a series of strings
 
     from cogent3 import make_aligned_seqs
 
-    seqs = [">seq1", "AATCG-A", ">seq2", "AATCGGA"]
+    seqs = {"seq1": "AATCG-A", "seq2": "AATCGGA"}
     seqs_loaded = make_aligned_seqs(seqs)
     seqs_loaded
 
@@ -145,12 +147,10 @@ Load a list of aligned nucleotide sequences, while specifying the DNA molecule t
 
     from cogent3 import make_aligned_seqs
 
-    DNA_seqs = [
-        ">sample1 Mus musculus",
-        "AACCTGC--C",
-        ">sample2 Gallus gallus",
-        "AAC-TGCAAC",
-    ]
+    DNA_seqs = {
+        "sample1 Mus musculus": "AACCTGC--C",
+        "sample2 Gallus gallus": "AAC-TGCAAC",
+    }
     loaded_seqs = make_aligned_seqs(
         DNA_seqs, moltype="dna", label_to_name=lambda x: x.split()[0]
     )
diff --git a/src/cogent3/app/sample.py b/src/cogent3/app/sample.py
index c6c53e685..a335f944e 100644
--- a/src/cogent3/app/sample.py
+++ b/src/cogent3/app/sample.py
@@ -329,7 +329,7 @@ class take_n_seqs:
             self._names = data.names[: self._number]
             return
 
-        self._names = np_random.choice(data.names, self._number, replace=False)
+        self._names = np_random.choice(data.names, self._number, replace=False).tolist()
 
     T = Union[SerialisableType, SeqsCollectionType]
 
diff --git a/src/cogent3/core/alignment.py b/src/cogent3/core/alignment.py
index 6bb9e4c39..ae3337312 100644
--- a/src/cogent3/core/alignment.py
+++ b/src/cogent3/core/alignment.py
@@ -250,7 +250,10 @@ def coerce_to_string(s):
         return "".join(map(str, s))
 
 
-def seqs_from_array(a, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def seqs_from_array(a, alphabet=None):  # pragma: no cover
     """SequenceCollection from array of pos x seq: names are integers.
 
     This is an InputHandler for SequenceCollection. It converts an arbitrary
@@ -259,7 +262,10 @@ def seqs_from_array(a, alphabet=None):
     return list(transpose(a)), None
 
 
-def seqs_from_array_seqs(seqs, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def seqs_from_array_seqs(seqs, alphabet=None):  # pragma: no cover
     """Alignment from ArraySequence objects: seqs -> array, names from seqs.
 
     This is an InputHandler for SequenceCollection. It converts a list of
@@ -269,7 +275,10 @@ def seqs_from_array_seqs(seqs, alphabet=None):
     return seqs, [s.name for s in seqs]
 
 
-def seqs_from_generic(seqs, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def seqs_from_generic(seqs, alphabet=None):  # pragma: no cover
     """returns seqs, names"""
     names = []
     for s in seqs:
@@ -280,7 +289,10 @@ def seqs_from_generic(seqs, alphabet=None):
     return seqs, names
 
 
-def seqs_from_fasta(seqs, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def seqs_from_fasta(seqs, alphabet=None):  # pragma: no cover
     """SequenceCollection from FASTA-format string or lines.
 
     This is an InputHandler for SequenceCollection. It converts a FASTA-format
@@ -293,7 +305,10 @@ def seqs_from_fasta(seqs, alphabet=None):
     return list(seqs), list(names)
 
 
-def seqs_from_dict(seqs, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def seqs_from_dict(seqs, alphabet=None):  # pragma: no cover
     """SequenceCollection from dict of {label:seq_as_str}.
 
     This is an InputHandler for SequenceCollection. It converts a dict in
@@ -306,7 +321,10 @@ def seqs_from_dict(seqs, alphabet=None):
     return seqs, names
 
 
-def seqs_from_kv_pairs(seqs, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def seqs_from_kv_pairs(seqs, alphabet=None):  # pragma: no cover
     """SequenceCollection from list of (key, val) pairs.
 
     This is an InputHandler for SequenceCollection. It converts a dict in
@@ -319,7 +337,10 @@ def seqs_from_kv_pairs(seqs, alphabet=None):
     return seqs, names
 
 
-def seqs_from_aln(seqs, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def seqs_from_aln(seqs, alphabet=None):  # pragma: no cover
     """SequenceCollection from existing SequenceCollection object: copies data.
 
     This is relatively inefficient: you should really use the copy() method
@@ -328,7 +349,10 @@ def seqs_from_aln(seqs, alphabet=None):
     return seqs.seqs, seqs.names
 
 
-def seqs_from_empty(obj, *args, **kwargs):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def seqs_from_empty(obj, *args, **kwargs):  # pragma: no cover
     """SequenceCollection from empty data: raise exception."""
     raise ValueError("Cannot create empty SequenceCollection.")
 
@@ -379,6 +403,59 @@ def _(seqs: dict) -> SupportsFeatures:
     return merged_db_collection(seqs.values())
 
 
+@functools.singledispatch
+def _moltype_from_data(data):
+    """returns moltype if data has one"""
+    if not data:
+        return None
+
+    if hasattr(data, "moltype"):
+        return data.moltype
+    elif hasattr(data[1], "moltype"):
+        return data[1].moltype
+
+
+@_moltype_from_data.register
+def _(data: dict):
+    return _moltype_from_data(get_first_value(data))
+
+
+@_moltype_from_data.register
+def _(data: list):
+    return _moltype_from_data(get_first_value(data))
+
+
+@_moltype_from_data.register
+def _(data: tuple):
+    return _moltype_from_data(get_first_value(data))
+
+
+@_moltype_from_data.register
+def _(data: set):
+    return _moltype_from_data(get_first_value(data))
+
+
+@_moltype_from_data.register
+def _(data: str):
+    return None
+
+
+@_moltype_from_data.register
+def _(data: bytes):
+    return None
+
+
+@_moltype_from_data.register
+def _(data: ndarray):
+    return None
+
+
+@_moltype_from_data.register
+def _(data: None):
+    return None
+
+
+# GAH edit the docstrings on class and constructor
 @total_ordering
 class _SequenceCollectionBase:
     """
@@ -396,37 +473,29 @@ class _SequenceCollectionBase:
     - moltype: specifies what kind of sequences are in the collection
     """
 
-    _input_handlers = {
-        "array": seqs_from_array,
-        "array_seqs": seqs_from_array_seqs,
-        "generic": seqs_from_generic,
-        "fasta": seqs_from_fasta,
-        "collection": seqs_from_aln,
-        "aln": seqs_from_aln,
-        "array_aln": seqs_from_aln,
-        "dict": seqs_from_dict,
-        "empty": seqs_from_empty,
-        "kv_pairs": seqs_from_kv_pairs,
-    }
-
     is_array = set(["array", "array_seqs"])
 
-    _make_names = assign_sequential_names
-
+    @c3warn.deprecated_args(
+        "2024.3",
+        reason="simplifying API",
+        discontinued=(
+            "remove_duplicate_names",
+            "alphabet",
+            "suppress_named_seqs",
+            "force_same_data",
+        ),
+    )
     def __init__(
         self,
         data,
         names=None,
-        alphabet=None,
         moltype=None,
         name=None,
         info=None,
         conversion_f=None,
         is_array=False,
-        force_same_data=False,
-        remove_duplicate_names=False,
         label_to_name=None,
-        suppress_named_seqs=False,
+        **kwargs,  # delete me when deprecation takes effect
     ):
         """Initialize self with data and optionally info.
 
@@ -437,7 +506,7 @@ class _SequenceCollectionBase:
 
         The handling of sequence names requires special attention. Depending
         on the input data, we might get the names from the sequences themselves,
-        or we might add them from Names that are passed in. However, the Names
+        or we might add them from names that are passed in. However, the names
         attribute controls the order that we examine the sequences in, so if
         it is passed in it should override the order that we got from the
         input data (e.g. you might pass in unlabeled sequences with the names
@@ -458,115 +527,70 @@ class _SequenceCollectionBase:
         is already labeled (e.g. a list of Sequence objects) you _must_ have
         unique names beforehand.
 
-        It's possible that this additional handling should be moved to a
-        separate object; the motivation for having it on Alignment __init__
-        is that it's easy for users to construct Alignment objects directly.
 
         Parameters
         ----------
 
         data
             Data to convert into a SequenceCollection
-        Names
-            Order of Names in the alignment. Should match the
+        names
+            Order of names in the alignment. Should match the
             names of the sequences (after processing by
             label_to_name if present).
-        alphabet
-            Alphabet to use for the alignment (primarily important
-            for ArrayAlignment)
         moltype
-            moltype to be applied to the Alignment and to each seq.
+            moltype to be applied to the collection and to each seq. The alphabet
+            is derived from this.
         name
             name of the SequenceCollection.
         info
             info object to be attached to the alignment itself.
         conversion_f
-            Function to convert string into sequence.
+            Function to convert input sequence data. These are automatically
+            specified for the different sublcasses.
         is_array
             True if input is an array, False otherwise.
-        force_same_data
-            True if data will be used as the same object.
-        remove_duplicate_names
-            True if duplicate names are to be silently
-            deleted instead of raising errors.
         label_to_name
             if present, converts name into f(name).
-        suppress_named_seqs
-            create name_seqs attribute if True (default)
         """
+        if isinstance(data, (typing.Generator, typing.Iterator)):
+            data = tuple(data)
 
-        # read all the data in if we were passed a generator
-        if isinstance(data, GeneratorType):
-            data = list(data)
-
-        input_type = self._guess_input_type(data)
-        if input_type in ("aln", "collection"):
-            anno_db = merged_db_collection(data.seqs)
-        elif input_type == "kv_pairs":
-            anno_db = merged_db_collection(dict(data))
-        elif isinstance(data, (tuple, list, dict)):
-            anno_db = merged_db_collection(data)
-        else:
-            anno_db = None
+        if moltype is None:
+            moltype = _moltype_from_data(data)
+        moltype = cogent3.get_moltype(moltype or self.moltype)
+        seqs, names = conversion_f(
+            data, names, moltype=moltype, label_to_name=label_to_name or str
+        )
+
+        self.moltype = moltype
+        try:
+            alphabet = moltype.alphabets.degen_gapped
+        except AttributeError:
+            alphabet = moltype.alphabet
+
+        self.alphabet = alphabet
+        self.names = list(names)
+        self._named_seqs = None
         # set the name
         self.name = name
-        names = list(names) if names is not None else names
-        # figure out alphabet and moltype
-        self.alphabet, self.moltype = self._get_alphabet_and_moltype(
-            alphabet, moltype, data
-        )
+        self._repr_policy = dict(num_seqs=10, num_pos=60, ref_name="longest", wrap=60)
+
         if not isinstance(info, InfoClass):
             if info:
                 info = InfoClass(info)
             else:
                 info = InfoClass()
         self.info = info
-        # if we're forcing the same data, skip the validation
-        if force_same_data:
-            self._force_same_data(data, names)
-            if isinstance(data, dict):
-                curr_seqs = list(data.values())
-            else:
-                curr_seqs = data
-        # otherwise, figure out what we got and coerce it into the right type
-        else:
-            per_seq_names, curr_seqs, name_order = self._names_seqs_order(
-                conversion_f,
-                data,
-                names,
-                is_array,
-                label_to_name,
-                remove_duplicate_names,
-                alphabet=self.alphabet,
-            )
-            self.names = list(name_order)
-
-            # will take only the seqs and names that are in name_order
-            if per_seq_names != name_order:
-                good_indices = []
-                for n in name_order:
-                    good_indices.append(per_seq_names.index(n))
-                if hasattr(curr_seqs, "astype"):  # it's an array
-                    # much faster to check than to raise exception in this case
-                    curr_seqs = take(curr_seqs, good_indices, axis=0)
-                else:
-                    curr_seqs = [curr_seqs[i] for i in good_indices]
-
-            # create named_seqs dict for fast lookups
-            if not suppress_named_seqs:
-                self.named_seqs = _make_named_seqs(self.names, curr_seqs)
-        # Sequence objects behave like sequences of chars, so no difference
-        # between seqs and seq_data. Note that this differs for Alignments,
-        # so be careful which you use if writing methods that should work for
-        # both SequenceCollections and Alignments.
-        self._set_additional_attributes(curr_seqs)
 
+        self._set_additional_attributes(seqs)
         self._repr_policy = dict(num_seqs=10, num_pos=60, ref_name="longest", wrap=60)
-
         self._annotation_db = None
 
-        if not isinstance(self, ArrayAlignment):
-            self.annotation_db = anno_db or DEFAULT_ANNOTATION_DB()
+    @property
+    def named_seqs(self):
+        if self._named_seqs is None:
+            self._named_seqs = _make_named_seqs(self.names, self._seqs)
+        return self._named_seqs
 
     @property
     def annotation_db(self):
@@ -597,12 +621,6 @@ class _SequenceCollectionBase:
         except ValueError:  # got empty sequence, for some reason?
             self.seq_len = 0
 
-    def _force_same_data(self, data, names):
-        """Forces dict that was passed in to be used as self.named_seqs"""
-        assert isinstance(data, dict), "force_same_data requires input data is a dict"
-        self.named_seqs = data
-        self.names = names or list(data.keys())
-
     def copy(self):
         """Returns deep copy of self."""
         result = self.__class__(self, moltype=self.moltype, info=self.info)
@@ -633,165 +651,11 @@ class _SequenceCollectionBase:
             new_seqs[seq.name] = new_seq
 
         info = deepcopy(self.info)
-        result = self.__class__(
-            new_seqs, moltype=self.moltype, info=info, force_same_data=True
-        )
+        result = self.__class__(new_seqs, moltype=self.moltype, info=info)
         result.annotation_db = db
         result._repr_policy.update(self._repr_policy)
         return result
 
-    def _get_alphabet_and_moltype(self, alphabet, moltype, data):
-        """Returns alphabet and moltype, giving moltype precedence."""
-        if type(moltype) == str:
-            from cogent3.core.moltype import get_moltype
-
-            moltype = get_moltype(moltype)
-
-        if alphabet is None and moltype is None:
-            if hasattr(data, "moltype"):
-                moltype = data.moltype
-            elif hasattr(data, "alphabet"):
-                alphabet = data.alphabet
-            # check for containers
-            else:
-                curr_item = get_first_value(data)
-                if hasattr(curr_item, "moltype"):
-                    moltype = curr_item.moltype
-                elif hasattr(curr_item, "alphabet"):
-                    alphabet = curr_item.alphabet
-                else:
-                    moltype = self.moltype  # will be BYTES by default
-        if alphabet is not None and moltype is None:
-            moltype = alphabet.moltype
-        if moltype is not None and alphabet is None:
-            try:
-                alphabet = moltype.alphabets.degen_gapped
-            except AttributeError:
-                alphabet = moltype.alphabet
-        return alphabet, moltype
-
-    def _names_seqs_order(
-        self,
-        conversion_f,
-        data,
-        name_order,
-        is_array,
-        label_to_name,
-        remove_duplicate_names,
-        alphabet=None,
-    ):
-        """Internal function to figure out names, seqs, and name_order."""
-        # figure out conversion function and whether it's an array
-        if not conversion_f:
-            input_type = self._guess_input_type(data)
-            is_array = input_type in self.is_array
-            conversion_f = self._input_handlers[input_type]
-        # set seqs and names as properties
-        if alphabet:
-            seqs, names = conversion_f(data, alphabet=alphabet)
-        else:
-            seqs, names = conversion_f(data)
-        if names and label_to_name:
-            names = list(map(label_to_name, names))
-        curr_seqs = self._coerce_seqs(seqs)
-
-        # if no names were passed in as Names, if we obtained them from
-        # the seqs we should use them, but otherwise we should use the
-        # default names
-        if name_order is None:
-            if (names is None) or (None in names):
-                per_seq_names = name_order = self._make_names(len(curr_seqs))
-            else:  # got names from seqs
-                per_seq_names = name_order = names
-        else:
-            # otherwise, names were passed in as Names: use this as the order
-            # if we got names from the sequences, but otherwise assign the
-            # names to successive sequences in order
-            if (names is None) or (None in names):
-                per_seq_names = name_order
-            else:  # got names from seqs, so assume name_order is in Names
-                per_seq_names = names
-
-        # check for duplicate names
-        duplicates, fixed_names, fixed_seqs = _strip_duplicates(
-            per_seq_names, curr_seqs
-        )
-        if duplicates:
-            if remove_duplicate_names:
-                per_seq_names, curr_seqs = fixed_names, fixed_seqs
-                # if name_order doesn't have the same names as per_seq_names,
-                # replace it with per_seq_names
-                if (set(name_order) != set(per_seq_names)) or (
-                    len(name_order) != len(per_seq_names)
-                ):
-                    name_order = per_seq_names
-            else:
-                raise ValueError(
-                    f"Some names were not unique. Duplicates are: {duplicates}"
-                )
-
-        return per_seq_names, curr_seqs, name_order
-
-    def _coerce_seqs(self, seqs):
-        """Controls how seqs are coerced in _names_seqs_order.
-
-        Override in subclasses where this behavior should differ.
-        """
-        return list(map(self.moltype.make_seq, seqs))
-
-    def _guess_input_type(self, data):
-        """Guesses input type of data; returns result as key of _input_handlers.
-
-        First checks whether data is an Alignment, then checks for some common
-        string formats, then tries to do it based on string or array properties.
-
-        Returns 'empty' if check fails, i.e. if it can't recognize the sequence
-        as a specific type. Note that bad sequences are not guaranteed to
-        return 'empty', and may be recognized as another type incorrectly.
-        """
-        from cogent3.core.sequence import Sequence
-
-        try:
-            length = len(data)
-        except TypeError:
-            length = 0
-
-        if length == 0:
-            return "empty"
-
-        if isinstance(data, ArrayAlignment):
-            return "array_aln"
-        if isinstance(data, Alignment):
-            return "aln"
-        if isinstance(data, SequenceCollection):
-            return "collection"
-        if isinstance(data, dict):
-            return "dict"
-        if isinstance(data, str):
-            if data.startswith(">"):
-                return "fasta"
-            else:
-                return "generic"
-
-        first = get_first_value(data)
-        if first is None:
-            return "empty"
-
-        if isinstance(first, ArraySequence):  # model sequence base type
-            return "array_seqs"
-        if hasattr(first, "dtype"):  # array object
-            return "array"
-        if isinstance(first, str) and first.startswith(">"):
-            return "fasta"
-        if isinstance(first, Aligned) or isinstance(first, Sequence):
-            return "generic"
-        try:
-            dict(data)
-            return "kv_pairs"
-        except (TypeError, ValueError):
-            pass
-        return "generic"
-
     def __eq__(self, other):
         """first tests as dict, then as str"""
         c = self.named_seqs == other
@@ -837,11 +701,11 @@ class _SequenceCollectionBase:
         for key in seq_order or self.names:
             yield get(key)
 
-    def _take_seqs(self):
+    @property
+    def seqs(self):
         return list(self.iter_seqs())
 
     # access as attribute if using default order.
-    seqs = property(_take_seqs)
 
     def take_seqs(self, seqs, negate=False, **kwargs):
         """Returns new Alignment containing only specified seqs.
@@ -1207,7 +1071,9 @@ class _SequenceCollectionBase:
                 seq.__class__ == self_seq_class
             ), f"Seq classes different: Expected {seq.__class__}, Got {self_seq_class}"
 
-        combined_aln = self.__class__(data=combined, info=self.info)
+        combined_aln = self.__class__(
+            data=combined, info=self.info, moltype=self.moltype
+        )
 
         if before_name is None and after_name is None:
             return combined_aln
@@ -1670,7 +1536,11 @@ class _SequenceCollectionBase:
         """Returns the reverse complement alignment"""
         seqs = [self.named_seqs[name].rc() for name in self.names]
         rc = self.__class__(
-            data=seqs, names=self.names[:], name=self.name, info=self.info
+            data=seqs,
+            names=self.names[:],
+            name=self.name,
+            info=self.info,
+            moltype=self.moltype,
         )
         rc.annotation_db = self.annotation_db
         return rc
@@ -2026,6 +1896,14 @@ class _SequenceCollectionBase:
 class SequenceCollection(_SequenceCollectionBase):
     """Container for unaligned sequences"""
 
+    moltype = None  # assigned to ASICII in moltype
+
+    def __init__(self, *args, **kwargs):
+        kwargs["conversion_f"] = kwargs.get("conversion_f", _coerce_to_unaligned_seqs)
+        super().__init__(*args, **kwargs)
+        anno_db = merged_db_collection(self.seqs)
+        self.annotation_db = anno_db or DEFAULT_ANNOTATION_DB()
+
     def copy_annotations(self, seq_db: SupportsFeatures) -> None:
         """copy annotations into attached annotation db
 
@@ -2278,11 +2156,10 @@ class Aligned:
             allow_multiple=allow_multiple,
         )
 
-    def _get_moltype(self):
+    @property
+    def moltype(self):
         return self.data.moltype
 
-    moltype = property(_get_moltype)
-
     def copy(self):
         """Returns a shallow copy of self"""
         return self.__class__(self.map, self.data)
@@ -2545,7 +2422,9 @@ class AlignmentI(object):
         else:
             for name, seq in list(self.named_seqs.items()):
                 result[name] = make_seq("".join(str(seq[i]) for i in cols))
-        return self.__class__(result, names=self.names, info=self.info)
+        return self.__class__(
+            result, names=self.names, info=self.info, moltype=self.moltype
+        )
 
     def get_position_indices(self, f, native=False, negate=False):
         """Returns list of column indices for which f(col) is True.
@@ -3770,7 +3649,10 @@ def _one_length(seqs):
         raise ValueError("not all sequences have same length")
 
 
-def aln_from_array(a, array_type=None, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def aln_from_array(a, array_type=None, alphabet=None):  # pragma: no cover
     """Alignment from array of pos x seq: no change, names are integers.
 
     This is an InputHandler for Alignment. It converts an arbitrary array
@@ -3785,7 +3667,10 @@ def aln_from_array(a, array_type=None, alphabet=None):
     return transpose(result), None
 
 
-def aln_from_array_seqs(seqs, array_type=None, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def aln_from_array_seqs(seqs, array_type=None, alphabet=None):  # pragma: no cover
     """Alignment from ArraySequence objects: seqs -> array, names from seqs.
 
     This is an InputHandler for Alignment. It converts a list of Sequence
@@ -3813,7 +3698,10 @@ def aln_from_array_seqs(seqs, array_type=None, alphabet=None):
     return result, names
 
 
-def aln_from_generic(data, array_type=None, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def aln_from_generic(data, array_type=None, alphabet=None):  # pragma: no cover
     """Alignment from generic seq x pos data: sequence of sequences of chars.
 
     This is an InputHandler for Alignment. It converts a generic list (each
@@ -3835,7 +3723,10 @@ def aln_from_generic(data, array_type=None, alphabet=None):
     return result, names
 
 
-def aln_from_collection(seqs, array_type=None, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def aln_from_collection(seqs, array_type=None, alphabet=None):  # pragma: no cover
     """Alignment from SequenceCollection object, or its subclasses."""
     names = seqs.names
     data = [seqs.named_seqs[i] for i in names]
@@ -3845,7 +3736,10 @@ def aln_from_collection(seqs, array_type=None, alphabet=None):
     return result, names
 
 
-def aln_from_fasta(seqs, array_type=None, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def aln_from_fasta(seqs, array_type=None, alphabet=None):  # pragma: no cover
     """Alignment from FASTA-format string or lines.
 
     This is an InputHandler for Alignment. It converts a FASTA-format string
@@ -3867,7 +3761,10 @@ def aln_from_fasta(seqs, array_type=None, alphabet=None):
     )
 
 
-def aln_from_dict(aln, array_type=None, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def aln_from_dict(aln, array_type=None, alphabet=None):  # pragma: no cover
     """Alignment from dict of {label:seq_as_str}.
 
     This is an InputHandler for Alignment. It converts a dict in which the
@@ -3887,7 +3784,10 @@ def aln_from_dict(aln, array_type=None, alphabet=None):
     return result, list(names)
 
 
-def aln_from_kv_pairs(aln, array_type=None, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def aln_from_kv_pairs(aln, array_type=None, alphabet=None):  # pragma: no cover
     """Alignment from sequence of (key, value) pairs.
 
     This is an InputHandler for Alignment. It converts a list in which the
@@ -3902,7 +3802,10 @@ def aln_from_kv_pairs(aln, array_type=None, alphabet=None):
     return result, list(names)
 
 
-def aln_from_array_aln(aln, array_type=None, alphabet=None):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def aln_from_array_aln(aln, array_type=None, alphabet=None):  # pragma: no cover
     """Alignment from existing ArrayAlignment object: copies data.
 
     Retrieves data from positions field. Uses copy(), so array data type
@@ -3915,7 +3818,10 @@ def aln_from_array_aln(aln, array_type=None, alphabet=None):
     return transpose(result), aln.names[:]
 
 
-def aln_from_empty(obj, *args, **kwargs):
+@c3warn.deprecated_args(
+    "2024.3", reason="replaced by different loading mechanism", discontinued=True
+)
+def aln_from_empty(obj, *args, **kwargs):  # pragma: no cover
     """Alignment from empty data: raise exception."""
     raise ValueError("Cannot create empty alignment.")
 
@@ -3966,10 +3872,6 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
 
     SequenceType: Constructor to use when building sequences. Default: Sequence
 
-    _input_handlers: dict of {input_type:input_handler} where input_handler is
-    from the _input_handlers above and input_type is a result of the method
-    self._guess_input_type (should always be a string).
-
     Creating a new array will always result in a new object unless you use
     the force_same_object=True parameter.
 
@@ -3986,35 +3888,21 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
     moltype = None  # will be set to BYTES on moltype import
     alphabet = None  # will be set to BYTES.alphabet on moltype import
 
-    _input_handlers = {
-        "array": aln_from_array,
-        "array_seqs": aln_from_array_seqs,
-        "generic": aln_from_generic,
-        "fasta": aln_from_fasta,
-        "array_aln": aln_from_array_aln,
-        "aln": aln_from_collection,
-        "collection": aln_from_collection,
-        "dict": aln_from_dict,
-        "kv_pairs": aln_from_kv_pairs,
-        "empty": aln_from_empty,
-    }
-
     def __init__(self, *args, **kwargs):
         """Returns new ArrayAlignment object. Inherits from SequenceCollection."""
-        kwargs["suppress_named_seqs"] = True
+        kwargs["conversion_f"] = _coerce_to_array_aligned_seqs
         super(ArrayAlignment, self).__init__(*args, **kwargs)
         self.array_positions = transpose(self.seq_data.astype(self.alphabet.array_type))
         self.array_seqs = transpose(self.array_positions)
         self.seq_data = self.array_seqs
         self.seq_len = len(self.array_positions)
 
-    def _force_same_data(self, data, names):
-        """Forces array that was passed in to be used as selfarray_positions"""
-        if isinstance(data, ArrayAlignment):
-            data = data._positions
-
-        self.array_positions = data
-        self.names = names or self._make_names(len(data[0]))
+    def _set_additional_attributes(self, curr_seqs):
+        """Sets additional attributes based on current seqs: class-specific."""
+        curr_seqs = numpy.array(curr_seqs)
+        self.seq_data = curr_seqs
+        self._seqs = curr_seqs
+        self.seq_len = curr_seqs.shape[1] if len(curr_seqs) else 0
 
     def _get_positions(self):
         """Override superclass positions to return positions as symbols."""
@@ -4022,16 +3910,15 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
 
     positions = property(_get_positions)
 
-    def _get_named_seqs(self):
-        if not hasattr(self, "_named_seqs"):
+    @property
+    def named_seqs(self):
+        if self._named_seqs is None:
             seqs = list(map(self.alphabet.to_string, self.array_seqs))
             if self.moltype:
                 seqs = [self.moltype.make_seq(s, preserve_case=True) for s in seqs]
             self._named_seqs = _make_named_seqs(self.names, seqs)
         return self._named_seqs
 
-    named_seqs = property(_get_named_seqs)
-
     def __iter__(self):
         """iter(aln) iterates over positions, returning array slices.
 
@@ -4051,11 +3938,10 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
         else:
             data = self.array_seqs[:, item]
         result = self.__class__(
-            data.T,
+            data,
             list(map(str, self.names)),
-            self.alphabet,
-            conversion_f=aln_from_array,
             info=self.info,
+            moltype=self.moltype,
         )
         result._repr_policy.update(self._repr_policy)
         return result
@@ -4067,18 +3953,23 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
         """
         return seqs
 
+    @c3warn.deprecated_args(
+        "2024.3",
+        reason="naming consistency",
+        old_new=(("invert_seqs", "negate_seqs"), ("invert_pos", "negate_pos")),
+    )
     def get_sub_alignment(
-        self, seqs=None, pos=None, invert_seqs=False, invert_pos=False
+        self, seqs=None, pos=None, negate_seqs=False, negate_pos=False
     ):
         """Returns subalignment of specified sequences and positions.
 
         seqs and pos can be passed in as lists of sequence indices to keep
         or positions to keep.
 
-        invert_seqs: if True (default False), gets everything _except_ the
+        negate_seqs: if True (default False), gets everything _except_ the
         specified sequences.
 
-        invert_pos: if True (default False), gets everything _except_ the
+        negate_pos: if True (default False), gets everything _except_ the
         specified positions.
 
         Unlike most of the other code that gets things out of an alignment,
@@ -4087,7 +3978,7 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
         """
         # figure out which positions to keep, and keep them
         if pos is not None:
-            if invert_pos:
+            if negate_pos:
                 pos_mask = ones(len(self.array_positions))
                 put(pos_mask, pos, 0)
                 pos = nonzero(pos_mask)[0]
@@ -4096,7 +3987,7 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
             data = self.array_positions
         # figure out which sequences to keep, and keep them
         if seqs is not None:
-            if invert_seqs:
+            if negate_seqs:
                 seq_mask = ones(len(self.array_seqs))
                 put(seq_mask, seqs, 0)
                 seqs = nonzero(seq_mask)[0]
@@ -4105,11 +3996,10 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
         else:
             names = self.names
         return self.__class__(
-            data,
+            data.T,
             list(map(str, names)),
-            self.alphabet,
-            conversion_f=aln_from_array,
             info=self.info,
+            moltype=self.moltype,
         )
 
     def __str__(self):
@@ -4203,7 +4093,6 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
         return self.__class__(
             positions.T,
             moltype=self.moltype,
-            force_same_data=True,
             info=self.info,
             names=self.names,
         )
@@ -4250,7 +4139,6 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
         positions = self.array_seqs.take(indices, axis=1)
         return self.__class__(
             positions,
-            force_same_data=True,
             moltype=self.moltype,
             info=self.info,
             names=self.names,
@@ -4367,7 +4255,7 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
         If seqs is an alignment, any gaps in it will be ignored.
         """
         if not hasattr(seqs, "named_seqs"):
-            seqs = SequenceCollection(seqs)
+            seqs = SequenceCollection(seqs, moltype=self.moltype)
 
         seqs = seqs.degap()
 
@@ -4408,7 +4296,7 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
             new_seqarr[seqindex] = new
 
         return self.__class__(
-            new_seqarr.T, names=self.names, moltype=seqs.moltype, info=self.info
+            new_seqarr, names=self.names, moltype=seqs.moltype, info=self.info
         )
 
     def to_moltype(self, moltype):
@@ -4488,7 +4376,6 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
         positions = deepcopy(self.array_seqs)
         result = self.__class__(
             positions,
-            force_same_data=True,
             moltype=self.moltype,
             info=info,
             names=self.names,
@@ -4671,16 +4558,7 @@ class ArrayAlignment(AlignmentI, _SequenceCollectionBase):
 class CodonArrayAlignment(ArrayAlignment):  # pragma: no cover
     """Stores alignment of gapped codons, no degenerate symbols."""
 
-    _input_handlers = {
-        "array": aln_from_array,
-        "seqs": aln_from_array_seqs,
-        "generic": aln_from_generic,
-        "array_aln": aln_from_array_aln,
-        "aln": aln_from_collection,
-        "collection": aln_from_collection,
-        "dict": aln_from_dict,
-        "empty": aln_from_empty,
-    }
+    ...
 
 
 def make_gap_filter(template, gap_fraction, gap_run):
@@ -4724,30 +4602,9 @@ class Alignment(AlignmentI, SequenceCollection):
 
     def __init__(self, *args, **kwargs):
         """Returns new Alignment object: see SequenceCollection."""
-
+        kwargs["conversion_f"] = _coerce_to_aligned_seqs
         SequenceCollection.__init__(self, *args, **kwargs)
 
-        # need to convert seqs to Aligned objects
-        seqs = self.seq_data
-        names = self.names
-
-        self._motif_probs = {}
-        lengths = list(map(len, self.seq_data))
-        if lengths and (max(lengths) != min(lengths)):
-            raise DataError(
-                "Not all sequences are the same length:\n"
-                + f"max is {max(lengths)}, min is {min(lengths)}"
-            )
-        aligned_seqs = []
-        for s, n in zip(seqs, names):
-            if isinstance(s, Aligned):
-                s.name = n  # ensure consistency
-                aligned_seqs.append(s)
-            else:
-                aligned_seqs.append(self._seq_to_aligned(s, n))
-        self.named_seqs = dict(list(zip(names, aligned_seqs)))
-        self.seq_data = self._seqs = aligned_seqs
-
     def _coerce_seqs(self, seqs):
         if not any(isinstance(seq, (Sequence, Aligned)) for seq in seqs):
             seqs = list(map(self.moltype.make_seq, seqs))
@@ -4777,7 +4634,9 @@ class Alignment(AlignmentI, SequenceCollection):
         elif isinstance(index, (int, slice)):
             seqs = [s[index] for s in self.seqs]
 
-            new = self.__class__(seqs, name=self.name, info=self.info)
+            new = self.__class__(
+                seqs, name=self.name, info=self.info, moltype=self.moltype
+            )
 
         if isinstance(index, (list, tuple)):
             raise TypeError(f"cannot slice using {type(index)}")
@@ -4907,7 +4766,9 @@ class Alignment(AlignmentI, SequenceCollection):
             # todo gah why is _masked_annotations semi-private? add public method
             # on Aligned
             masked_seqs += [seq._masked_annotations(biotypes, mask_char, shadow)]
-        new = self.__class__(data=masked_seqs, info=self.info, name=self.name)
+        new = self.__class__(
+            data=masked_seqs, info=self.info, name=self.name, moltype=self.moltype
+        )
         new.annotation_db = self.annotation_db
         return new
 
@@ -5004,7 +4865,7 @@ class Alignment(AlignmentI, SequenceCollection):
                 else:
                     combo.append(str(s))
             result[name] = combo
-        return Alignment(result, alphabet=self.alphabet.with_gap_motif())
+        return Alignment(result, moltype=self.moltype)
 
     def get_degapped_relative_to(self, name):
         """Remove all columns with gaps in sequence with given name.
@@ -5078,7 +4939,7 @@ class Alignment(AlignmentI, SequenceCollection):
         """
 
         if type(ref_aln) != type(self):  # let the seq class try and guess
-            ref_aln = self.__class__(ref_aln)
+            ref_aln = self.__class__(ref_aln, moltype=ref_aln.moltype)
 
         ref_seq_name = ref_aln.names[0]
 
@@ -5105,10 +4966,12 @@ class Alignment(AlignmentI, SequenceCollection):
             seq = ref_aln.get_gapped_seq(seq_name)
             new_seq = Aligned(self.named_seqs[ref_seq_name].map, seq)
             if not temp_aln:
-                temp_aln = self.__class__({new_seq.name: str(new_seq)})
+                temp_aln = self.__class__(
+                    {new_seq.name: str(new_seq)}, moltype=self.moltype
+                )
             else:
                 temp_aln = temp_aln.add_seqs(
-                    self.__class__({new_seq.name: str(new_seq)})
+                    self.__class__({new_seq.name: str(new_seq)}, moltype=self.moltype)
                 )
 
         return self.add_seqs(temp_aln, before_name, after_name)
@@ -5151,7 +5014,7 @@ class Alignment(AlignmentI, SequenceCollection):
 
             new_seqs.append((label, Aligned(aligned.map * scale, seq)))
 
-        return self.__class__(new_seqs, info=self.info)
+        return self.__class__(new_seqs, info=self.info, moltype=self.moltype)
 
     def get_drawables(self, *, biotype: Optional[str, Iterable[str]] = None) -> dict:
         """returns a dict of drawables, keyed by type
@@ -5470,6 +5333,280 @@ class Alignment(AlignmentI, SequenceCollection):
             yield self.make_feature(feature=feature, on_alignment=on_al)
 
 
+def _make_name_seq_data(data):
+    # for sequence objects with a .name attribute
+    result = []
+    sequential = assign_sequential_names(None, num_seqs=len(data))
+    for i, record in enumerate(data):
+        record.name = record.name or sequential[i]
+        result.append((record.name, record))
+    return result
+
+
+# prep for SequenceCollection
+O = typing.Tuple[typing.List[Sequence], typing.List[str]]
+
+
+@functools.singledispatch
+def _coerce_to_unaligned_seqs(data, names, label_to_name=str, moltype=None) -> O:
+    """coerces data to be Sequence objects with moltype
+
+    Returns
+    -------
+    Lists of names and seqs
+
+    Notes
+    -----
+    Assuming data is a series of [name, seq] pairs, or a dict
+    {name: seq}
+    """
+    if isinstance(data, (typing.Generator, typing.Iterator)):
+        data = list(data)
+
+    first = get_first_value(data)
+    if hasattr(first, "name"):
+        data = _make_name_seq_data(data)
+
+    if isinstance(first, (str, ndarray)):
+        data = list(zip(names or assign_sequential_names(None, len(data)), data))
+
+    if moltype is None:
+        val = get_first_value(data)
+        moltype = getattr(val, "moltype", "text")
+
+    _check_name_consistency(data, names)
+
+    data = {label_to_name(name): seq for name, seq in data}
+    names = names or list(data.keys())
+    seqs = []
+    for name in names:
+        seq = _construct_unaligned_seq(data[name], moltype=moltype)
+        seq.name = name
+        seqs.append(seq)
+    return seqs, names
+
+
+def _check_name_consistency(data, names):
+    data_names = {n for n, _ in data}
+    if names and set(names) != data_names:
+        raise ValueError(
+            f"provided names do not match those in data: {set(names) - data_names}"
+        )
+    elif len(data) != len(data_names):
+        raise ValueError("duplicate names")
+
+
+@_coerce_to_unaligned_seqs.register
+def _(data: dict, names, label_to_name=str, moltype=None) -> O:
+    return _coerce_to_unaligned_seqs(
+        data.items(), names, label_to_name, moltype=moltype
+    )
+
+
+def _coerce_from_containers(data):
+    return [(s.name, s) for s in data.seqs]
+
+
+@_coerce_to_unaligned_seqs.register
+def _(
+    data: Alignment,
+    names,
+    label_to_name=str,
+    moltype=None,
+) -> O:
+    return _coerce_to_unaligned_seqs(
+        _coerce_from_containers(data), names, label_to_name, moltype
+    )
+
+
+@_coerce_to_unaligned_seqs.register
+def _(
+    data: SequenceCollection,
+    names,
+    label_to_name=str,
+    moltype=None,
+) -> O:
+    return _coerce_to_unaligned_seqs(
+        _coerce_from_containers(data), names, label_to_name, moltype
+    )
+
+
+@_coerce_to_unaligned_seqs.register
+def _(
+    data: ArrayAlignment,
+    names,
+    label_to_name=str,
+    moltype=None,
+) -> O:
+    return _coerce_to_unaligned_seqs(
+        _coerce_from_containers(data), names, label_to_name, moltype
+    )
+
+
+# prep data for ArrayAlignment
+O = typing.Tuple[ndarray, typing.List[str]]
+
+
+@functools.singledispatch
+def _coerce_to_array_aligned_seqs(data, names, label_to_name=str, moltype=None) -> O:
+    """coerces aligned data to be A numpy array objects with moltype
+
+    Returns
+    -------
+    Lists of names and seqs
+
+    Notes
+    -----
+    Assuming data is a series of [name, seq] pairs, or a dict
+    {name: seq}
+    """
+    if isinstance(data, (typing.Generator, typing.Iterator)):
+        data = list(data)
+
+    first = get_first_value(data)
+    if hasattr(first, "name"):
+        data = _make_name_seq_data(data)
+
+    if isinstance(first, (str, ndarray)):
+        data = list(zip(names or assign_sequential_names(None, len(data)), data))
+
+    if moltype is None:
+        val = get_first_value(data)
+        moltype = getattr(val, "moltype", "bytes")
+
+    _check_name_consistency(data, names)
+
+    data = {label_to_name(name): seq for name, seq in data}
+    names = names or list(data.keys())
+    seqs = []
+    for name in names:
+        seq = _construct_array_aligned_seq(data[name], moltype=moltype)
+        seqs.append(seq)
+
+    return numpy.array(seqs), names
+
+
+@_coerce_to_array_aligned_seqs.register
+def _(data: dict, names, label_to_name, moltype) -> O:
+    return _coerce_to_array_aligned_seqs(data.items(), names, label_to_name, moltype)
+
+
+@_coerce_to_array_aligned_seqs.register
+def _(data: ndarray, names, label_to_name, moltype) -> O:
+    if names is None:
+        names = assign_sequential_names(None, data.shape[0])
+    return _coerce_to_array_aligned_seqs(
+        tuple(zip(names, data)), names, label_to_name, moltype
+    )
+
+
+@_coerce_to_array_aligned_seqs.register
+def _(
+    data: ArrayAlignment,
+    names,
+    label_to_name,
+    moltype,
+) -> O:
+    return _coerce_to_array_aligned_seqs(
+        _coerce_from_containers(data), names, label_to_name, moltype
+    )
+
+
+@_coerce_to_array_aligned_seqs.register
+def _(
+    data: SequenceCollection,
+    names,
+    label_to_name,
+    moltype,
+) -> O:
+    return _coerce_to_array_aligned_seqs(
+        _coerce_from_containers(data), names, label_to_name, moltype
+    )
+
+
+# prep data for Alignment
+O = typing.Tuple[typing.List[Aligned], typing.List[str]]
+
+
+@functools.singledispatch
+def _coerce_to_aligned_seqs(data, names, label_to_name=str, moltype=None) -> O:
+    """coerces data to be Aligned objects with moltype
+
+    Returns
+    -------
+    Lists of names and seqs
+
+    Notes
+    -----
+    Assuming data is a series of [name, seq] pairs, or a dict
+    {name: seq}
+    """
+    if isinstance(data, (typing.Generator, typing.Iterator)):
+        data = list(data)
+
+    first = get_first_value(data)
+    if hasattr(first, "name"):
+        data = _make_name_seq_data(data)
+
+    if isinstance(first, (str, ndarray)):
+        data = list(zip(names or assign_sequential_names(None, len(data)), data))
+
+    if moltype is None:
+        val = get_first_value(data)
+        moltype = getattr(val, "moltype", "text")
+
+    _check_name_consistency(data, names)
+
+    data = {label_to_name(name): seq for name, seq in data}
+    names = names or list(data.keys())
+    seqs = []
+    for name in names:
+        seq = _construct_aligned_seq(data[name], moltype=moltype)
+        seq.name = seq.data.name = name
+        seqs.append(seq)
+
+    _one_length(seqs)
+    return seqs, names
+
+
+@_coerce_to_aligned_seqs.register
+def _(data: dict, names, label_to_name, moltype) -> O:
+    return _coerce_to_aligned_seqs(data.items(), names, label_to_name, moltype)
+
+
+@_coerce_to_aligned_seqs.register
+def _(data: ndarray, names, label_to_name, moltype) -> O:
+    names = names or assign_sequential_names(None, data.shape[0])
+    seqs = ["".join(moltype.alphabet.to_string(d)) for d in data]
+    return _coerce_to_aligned_seqs(
+        tuple(zip(names, seqs)), names, label_to_name, moltype
+    )
+
+
+@_coerce_to_aligned_seqs.register
+def _(
+    data: ArrayAlignment,
+    names,
+    label_to_name,
+    moltype,
+) -> O:
+    return _coerce_to_aligned_seqs(
+        _coerce_from_containers(data), names, label_to_name, moltype
+    )
+
+
+@_coerce_to_aligned_seqs.register
+def _(
+    data: SequenceCollection,
+    names,
+    label_to_name,
+    moltype,
+) -> O:
+    return _coerce_to_aligned_seqs(
+        _coerce_from_containers(data), names, label_to_name, moltype
+    )
+
+
 def _make_named_seqs(
     names: typing.Sequence[str], seqs: typing.Sequence[Sequence]
 ) -> dict[str, Sequence]:
@@ -5483,24 +5620,101 @@ def _make_named_seqs(
 T = typing.Sequence[typing.Union[Sequence, ndarray]]
 
 
-def _strip_duplicates(
-    names: typing.Sequence[str], seqs: T
-) -> typing.Tuple[set[str], list[str], list[T]]:
-    """Internal function to strip duplicates from list of names"""
-    if len(set(names)) == len(names):
-        return set(), names, seqs
-    # if we got here, there are duplicates
-    duplicates = set()
-    chosen_names = []
-    chosen_seqs = []
-    for n, s in zip(names, seqs):
-        if n in chosen_names:
-            duplicates.add(n)
-        else:
-            chosen_names.append(n)
-            chosen_seqs.append(s)
+# sequence conversion functions
+
+
+@functools.singledispatch
+def _construct_unaligned_seq(data, moltype) -> Sequence:
+    try:
+        result = data.to_moltype(moltype) if moltype else data
+    except AttributeError:
+        result = moltype.make_seq(data, preserve_case=False)
+    return result
+
+
+@_construct_unaligned_seq.register
+def _(data: str, moltype) -> Sequence:
+    return moltype.make_seq(data, preserve_case=False)
+
+
+@_construct_unaligned_seq.register
+def _(data: bytes, moltype) -> Sequence:
+    return _construct_unaligned_seq(data.decode("utf8"), moltype)
+
+
+@_construct_unaligned_seq.register
+def _(data: Aligned, moltype) -> Sequence:
+    return data.get_gapped_seq().to_moltype(moltype)
+
+
+@_construct_unaligned_seq.register
+def _(data: ndarray, moltype) -> Sequence:
+    return moltype.make_array_seq(data)
+
+
+@functools.singledispatch
+def _construct_aligned_seq(data, moltype) -> Aligned:
+    seq = _construct_unaligned_seq(data, moltype)
+    return Aligned(*seq.parse_out_gaps())
+
+
+@_construct_aligned_seq.register
+def _(data: Aligned, moltype) -> Aligned:
+    return data
+
+
+@_construct_aligned_seq.register
+def _(data: list, moltype) -> Aligned:
+    return _construct_aligned_seq("".join(data), moltype)
+
+
+@_construct_aligned_seq.register
+def _(data: tuple, moltype) -> Aligned:
+    return _construct_aligned_seq("".join(data), moltype)
+
+
+# convert seq data into a numpy array for an array alignment
+@functools.singledispatch
+def _construct_array_aligned_seq(data, moltype) -> ndarray:
+    """convert data into a 1D numpy array of int"""
+    if hasattr(data, "_data"):
+        # some type of ArraySequence
+        return data._data
+
+    if hasattr(data, "_seq"):
+        # some type of Sequence
+        return _construct_array_aligned_seq(str(data), moltype=moltype)
+
+    raise NotImplementedError(f"{type(data)} is not implemented")
+
+
+@_construct_array_aligned_seq.register
+def _(data: ndarray, moltype) -> ndarray:
+    assert data.ndim == 1
+    return data
+
+
+@_construct_array_aligned_seq.register
+def _(data: str, moltype) -> ndarray:
+    data = moltype.make_array_seq(data)
+    return data._data
+
+
+@_construct_array_aligned_seq.register
+def _(data: bytes, moltype) -> ndarray:
+    return _construct_array_aligned_seq(data.decode("utf8"), moltype=moltype)
+
+
+@_construct_array_aligned_seq.register
+def _(data: list, moltype) -> ndarray:
+    return array(data, dtype=numpy.uint8)
+
+
+@_construct_array_aligned_seq.register
+def _(data: tuple, moltype) -> ndarray:
+    return array(data, dtype=numpy.uint8)
 
-    if type(seqs) is ndarray:
-        chosen_seqs = array(chosen_seqs, seqs.dtype)
 
-    return duplicates, chosen_names, chosen_seqs
+@_construct_array_aligned_seq.register
+def _(data: Aligned, moltype) -> ndarray:
+    return _construct_array_aligned_seq(str(data), moltype=moltype)
diff --git a/src/cogent3/core/moltype.py b/src/cogent3/core/moltype.py
index b0f0a7184..9ebc02a08 100644
--- a/src/cogent3/core/moltype.py
+++ b/src/cogent3/core/moltype.py
@@ -1458,7 +1458,7 @@ ArrayRnaCodonSequence.alphabet = RNA.alphabets.base**3
 
 # Modify Alignment to avoid circular import
 Alignment.moltype = ASCII
-SequenceCollection.moltype = BYTES
+SequenceCollection.moltype = ASCII
 
 
 def _make_moltype_dict():
diff --git a/src/cogent3/util/misc.py b/src/cogent3/util/misc.py
index e2c95431e..8813645be 100644
--- a/src/cogent3/util/misc.py
+++ b/src/cogent3/util/misc.py
@@ -1103,8 +1103,9 @@ def get_first_value(data: typing.Iterable[typing.Any]):
     Returns the first element of data. If data is a dict, it will return
     the first element of data.values().
     """
-    if hasattr(data, "values"):
-        return next(iter(data.values()))
+    with contextlib.suppress(StopIteration):
+        if hasattr(data, "values"):
+            return next(iter(data.values()))
 
-    with contextlib.suppress(TypeError):
-        return next(iter(data))
+        with contextlib.suppress(TypeError):
+            return next(iter(data))
diff --git a/src/cogent3/util/recode_alignment.py b/src/cogent3/util/recode_alignment.py
index 92b78a120..f02ed5f62 100755
--- a/src/cogent3/util/recode_alignment.py
+++ b/src/cogent3/util/recode_alignment.py
@@ -420,14 +420,10 @@ def recode_dense_alignment(aln, alphabet_id=None, alphabet_def=None):
     # Map the old alphabet onto the new alphabet. Note: characters that
     # that are not mapped are ignored. Returns a new ArrayAlignment.
     return ArrayAlignment(
-        take(new_indices, aln.array_seqs).transpose(), aln.names[:], moltype=aln.moltype
+        take(new_indices, aln.array_seqs), aln.names[:], moltype=aln.moltype
     )
 
 
-def recode_alignment(aln, alphabet_id=None, alphabet_def=None):
-    raise NotImplementedError
-
-
 def recode_freq_vector(alphabet_def, freqs, ignores="BXZ"):
     """recode the bg_freqs to reflect the recoding defined in alphabet_def
 


Test patch:
diff --git a/tests/test_core/test_alignment.py b/tests/test_core/test_alignment.py
index c7336d12f..665a923c9 100644
--- a/tests/test_core/test_alignment.py
+++ b/tests/test_core/test_alignment.py
@@ -33,22 +33,10 @@ from cogent3.core.alignment import (
     ArrayAlignment,
     DataError,
     SequenceCollection,
+    _coerce_to_unaligned_seqs,
+    _construct_unaligned_seq,
     _SequenceCollectionBase,
-    aln_from_array,
-    aln_from_array_aln,
-    aln_from_array_seqs,
-    aln_from_collection,
-    aln_from_empty,
-    aln_from_fasta,
-    aln_from_generic,
     make_gap_filter,
-    seqs_from_aln,
-    seqs_from_array,
-    seqs_from_array_seqs,
-    seqs_from_empty,
-    seqs_from_fasta,
-    seqs_from_generic,
-    seqs_from_kv_pairs,
 )
 from cogent3.core.alphabet import AlphabetError
 from cogent3.core.annotation_db import GffAnnotationDb
@@ -59,110 +47,6 @@ from cogent3.parse.fasta import MinimalFastaParser
 from cogent3.util.misc import get_object_provenance
 
 
-class alignment_tests(TestCase):
-    """Tests of top-level functions."""
-
-    def test_seqs_from_array(self):
-        """seqs_from_array should return chars, and successive indices."""
-        a = array([[0, 1, 2], [2, 1, 0]])  # three 2-char seqs
-        obs_a, obs_labels = seqs_from_array(a)
-        # note transposition
-        assert_equal(obs_a, [array([0, 2]), array([1, 1]), array([2, 0])])
-        self.assertEqual(obs_labels, None)
-
-    def test_seqs_from_array_seqs(self):
-        """seqs_from_array_seqs should return model seqs + names."""
-        s1 = ArraySequence("ABC", name="a")
-        s2 = ArraySequence("DEF", name="b")
-        obs_a, obs_labels = seqs_from_array_seqs([s1, s2])
-        self.assertEqual(obs_a, [s1, s2])  # seq -> numbers
-        self.assertEqual(obs_labels, ["a", "b"])
-
-    def test_seqs_from_generic(self):
-        """seqs_from_generic should initialize seqs from list of lists, etc."""
-        s1 = "ABC"
-        s2 = "DEF"
-        obs_a, obs_labels = seqs_from_generic([s1, s2])
-        self.assertEqual(obs_a, ["ABC", "DEF"])
-        self.assertEqual(obs_labels, [None, None])
-
-    def test_seqs_from_fasta(self):
-        """seqs_from_fasta should initialize seqs from fasta-format string"""
-        s = ">aa\nAB\nC\n>bb\nDE\nF\n"
-        obs_a, obs_labels = seqs_from_fasta(s)
-        self.assertEqual(obs_a, ["ABC", "DEF"])
-        self.assertEqual(obs_labels, ["aa", "bb"])
-
-    def test_seqs_from_aln(self):
-        """seqs_from_aln should initialize from existing alignment"""
-        c = SequenceCollection(["abc", "def"])
-        obs_a, obs_labels = seqs_from_aln(c)
-        self.assertEqual(obs_a, ["abc", "def"])
-        self.assertEqual(obs_labels, ["seq_0", "seq_1"])
-
-    def test_seqs_from_kv_pairs(self):
-        """seqs_from_kv_pairs should initialize from key-value pairs"""
-        c = [["a", "abc"], ["b", "def"]]
-        obs_a, obs_labels = seqs_from_kv_pairs(c)
-        self.assertEqual(obs_a, ["abc", "def"])
-        self.assertEqual(obs_labels, ["a", "b"])
-
-    def test_seqs_from_empty(self):
-        """seqs_from_empty should always raise ValueError"""
-        self.assertRaises(ValueError, seqs_from_empty, "xyz")
-
-    def test_aln_from_array(self):
-        """aln_from_array should return same array, and successive indices."""
-        a = array([[0, 1, 2], [3, 4, 5]])  # three 2-char seqs
-        obs_a, obs_labels = aln_from_array(a)
-        assert_equal(obs_a, transpose(a))
-        assert_equal(obs_labels, None)
-
-    def test_aln_from_array_seqs(self):
-        """aln_from_array_seqs should initialize aln from sequence objects."""
-        s1 = ArraySequence("ACC", name="a", alphabet=RNA.alphabet)
-        s2 = ArraySequence("GGU", name="b", alphabet=RNA.alphabet)
-        obs_a, obs_labels = aln_from_array_seqs([s1, s2], alphabet=BYTES.alphabet)
-        assert_equal(obs_a, array([[2, 1, 1], [3, 3, 0]], "b"))
-        # seq -> numbers
-        assert_equal(obs_labels, ["a", "b"])
-
-    def test_aln_from_generic(self):
-        """aln_from_generic should initialize aln from list of lists, etc."""
-        s1 = "AAA"
-        s2 = "GGG"
-        obs_a, obs_labels = aln_from_generic(
-            [s1, s2], "b", alphabet=RNA.alphabet
-        )  # specify array type
-        assert_equal(obs_a, array([[2, 2, 2], [3, 3, 3]], "b"))  # str -> chars
-        assert_equal(obs_labels, [None, None])
-
-    def test_aln_from_fasta(self):
-        """aln_from_fasta should initialize aln from fasta-format string"""
-        s = ">aa\nAB\nC\n>bb\nDE\nF\n"
-        obs_a, obs_labels = aln_from_fasta(s.splitlines())
-        assert_equal(obs_a, array(["ABC", "DEF"], "c").view("B"))  # seq -> numbers
-        assert_equal(obs_labels, ["aa", "bb"])
-
-    def test_aln_from_array_aln(self):
-        """aln_from_array_aln should initialize from existing alignment"""
-        a = ArrayAlignment(array([[0, 1, 2], [3, 4, 5]]), conversion_f=aln_from_array)
-        obs_a, obs_labels = aln_from_array_aln(a)
-        assert_equal(obs_a, a.seq_data)
-        assert_equal(obs_labels, a.names)
-
-    def test_aln_from_collection(self):
-        """aln_from_collection should initialize from existing alignment"""
-        a = SequenceCollection(["AAA", "GGG"])
-        obs_a, obs_labels = aln_from_collection(a, alphabet=RNA.alphabet)
-        assert_equal(a.to_fasta(), ">seq_0\nAAA\n>seq_1\nGGG\n")
-        assert_equal(obs_a, array([[2, 2, 2], [3, 3, 3]]))
-
-    def test_aln_from_empty(self):
-        """aln_from_empty should always raise ValueError"""
-        self.assertRaises(ValueError, aln_from_empty, "xyz")
-
-
 class SequenceCollectionBaseTests(object):
     """base class for testing the SequenceCollection object.
 
@@ -230,23 +114,6 @@ class SequenceCollectionBaseTests(object):
         self.b = Alignment(["AAA", "AAA"])
         self.c = SequenceCollection(["AAA", "AAA"])
 
-    def test_guess_input_type(self):
-        """SequenceCollection  _guess_input_type should figure out data type correctly"""
-        git = self.a._guess_input_type
-        self.assertEqual(git(self.a), "array_aln")
-        self.assertEqual(git(self.b), "aln")
-        self.assertEqual(git(self.c), "collection")
-        self.assertEqual(git(">ab\nabc"), "fasta")
-        self.assertEqual(git([">ab", "abc"]), "fasta")
-        self.assertEqual(git(["abc", "def"]), "generic")
-        # precedence over generic
-        self.assertEqual(git([[1, 2], [4, 5]]), "kv_pairs")
-        self.assertEqual(git([[1, 2, 3], [4, 5, 6]]), "generic")
-        self.assertEqual(git([ArraySequence("abc")]), "array_seqs")
-        self.assertEqual(git(array([[1, 2, 3], [4, 5, 6]])), "array")
-        self.assertEqual(git({"a": "aca"}), "dict")
-        self.assertEqual(git([]), "empty")
-
     def test_init_aln(self):
         """SequenceCollection should init from existing alignments"""
         exp = self.Class(["AAA", "AAA"])
@@ -259,18 +126,6 @@ class SequenceCollectionBaseTests(object):
 
     test_init_aln.__doc__ = Class.__name__ + test_init_aln.__doc__
 
-    def test_init_dict(self):
-        """SequenceCollection init from dict should work as expected"""
-        d = {"a": "AAAAA", "b": "BBBBB"}
-        a = self.Class(d, names=["a", "b"])
-        self.assertEqual(a, d)
-        self.assertEqual(list(a.named_seqs.items()), list(d.items()))
-
-        # from bytes strings
-        a = self.Class({"a": b"AAAAA", "b": b"BBBBB"}, names=["a", "b"])
-        self.assertEqual(a, d)
-        self.assertEqual(list(a.named_seqs.items()), list(d.items()))
-
     def test_names_attribute(self):
         """expected to be a list"""
         seqs = self.Class({"a": b"AAAAA", "b": b"BBBBB"}, names=("a", "b"))
@@ -301,26 +156,6 @@ class SequenceCollectionBaseTests(object):
         self.assertEqual(a.names, ["seq_0", "seq_1", "seq_2"])
         self.assertEqual(list(a.seqs), ["AAAAA", "BBBBB", "CCCCC"])
 
-    def test_init_seq_info(self):
-        """SequenceCollection init from seqs w/ info should preserve data"""
-        a = Sequence("AAA", name="a", info={"x": 3})
-        b = Sequence("CCC", name="b", info={"x": 4})
-        c = Sequence("GGG", name="c", info={"x": 5})
-        seqs = [c, b, a]
-        a = self.Class(seqs)
-        self.assertEqual(list(a.names), ["c", "b", "a"])
-        self.assertEqual(list(map(str, a.seqs)), ["GGG", "CCC", "AAA"])
-        if self.Class is not ArrayAlignment:
-            # ArrayAlignment is allowed to strip info objects
-            self.assertEqual([i.info.x for i in a.seqs], [5, 4, 3])
-        # check it still works if constructed from same class
-        b = self.Class(a)
-        self.assertEqual(list(b.names), ["c", "b", "a"])
-        self.assertEqual(list(map(str, b.seqs)), ["GGG", "CCC", "AAA"])
-        if self.Class is not ArrayAlignment:
-            # ArrayAlignment is allowed to strip Info objects
-            self.assertEqual([i.info.x for i in b.seqs], [5, 4, 3])
-
     def test_init_pairs(self):
         """SequenceCollection init from list of (key,val) pairs should work correctly"""
         seqs = [["x", "XXX"], ["b", "BBB"], ["c", "CCC"]]
@@ -360,25 +195,6 @@ class SequenceCollectionBaseTests(object):
         aln = self.Class(["A-A", "CC-"], moltype=DNA)
         aln = self.Class(["A?A", "CC-"], moltype=DNA)
 
-    def test_aln_from_fasta_parser(self):
-        """aln_from_fasta_parser should init from iterator"""
-        s = ">aa\nAC\n>bb\nAA\n>c\nGG\n".splitlines()
-        p = MinimalFastaParser(s)
-        aln = self.Class(p, moltype=DNA)
-        self.assertEqual(aln.named_seqs["aa"], "AC")
-        self.assertEqual(aln.to_fasta(), ">aa\nAC\n>bb\nAA\n>c\nGG\n")
-        s2_ORIG = ">x\nCA\n>b\nAA\n>>xx\nGG"
-        s2 = ">aa\nAC\n>bb\nAA\n>c\nGG\n"
-        d = ArrayAlignment(MinimalFastaParser(s2.splitlines()))
-        d.to_fasta()
-        self.assertEqual(d.to_fasta(), aln.to_fasta())
-
-    def test_aln_from_fasta(self):
-        """SequenceCollection should init from fasta-format string"""
-        s = ">aa\nAC\n>bb\nAA\n>c\nGG\n"
-        aln = self.Class(s)
-        self.assertEqual(aln.to_fasta(), s)
-
     def test_seq_len_get(self):
         """SequenceCollection seq_len should return length of longest seq"""
         self.assertEqual(self.one_seq.seq_len, 5)
@@ -592,138 +408,6 @@ class SequenceCollectionBaseTests(object):
         got = frozenset(frozenset(s) for s in got)
         self.assertEqual(got, expect)
 
-    def test_get_similar(self):
-        """SequenceCollection get_similar should get all sequences close to target seq"""
-        aln = self.many
-        RnaSequence("GGGGGGGGGG")
-        RnaSequence("----------")
-        # test min and max similarity ranges
-        result = aln.get_similar(
-            aln.named_seqs["a"], min_similarity=0.4, max_similarity=0.7
-        )
-        for seq in "cefg":
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 4)
-
-        result = aln.get_similar(
-            aln.named_seqs["a"], min_similarity=0.95, max_similarity=1
-        )
-        for seq in "a":
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 1)
-
-        result = aln.get_similar(
-            aln.named_seqs["a"], min_similarity=0.75, max_similarity=0.85
-        )
-        for seq in "bd":
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 2)
-
-        result = aln.get_similar(
-            aln.named_seqs["a"], min_similarity=0, max_similarity=0.2
-        )
-        self.assertEqual(result, {})
-
-        # test some sequence transformations
-        def transform(s):
-            return s[1:4]
-
-        result = aln.get_similar(
-            aln.named_seqs["a"], min_similarity=0.5, transform=transform
-        )
-        for seq in "abdfg":
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 5)
-
-        def transform(s):
-            return s[-3:]
-
-        result = aln.get_similar(
-            aln.named_seqs["a"], min_similarity=0.5, transform=transform
-        )
-        for seq in "abcde":
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 5)
-
-        # test a different distance metric
-        def metric(x, y):
-            return str(x).count("G") + str(y).count("G")
-
-        result = aln.get_similar(
-            aln.named_seqs["a"], min_similarity=5, max_similarity=10, metric=metric
-        )
-        for seq in "ef":
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 2)
-
-        # test the combination of a transform and a distance metric
-        aln = self.Class(
-            dict(enumerate(map(RnaSequence, ["GA-GU", "A-GAC", "GG-GG"]))), moltype=RNA
-        )
-
-        def transform(s):
-            return RnaSequence(str(s).replace("G", "A").replace("U", "C"))
-
-        metric = RnaSequence.frac_same_non_gaps
-
-        def null_transform(s):
-            return RnaSequence(str(s))
-
-        # first, do it without the transformation
-        try:
-            result = aln.get_similar(
-                aln.named_seqs[0], min_similarity=0.5, metric=metric
-            )
-        except TypeError:  # need to coerce to RNA seq w/ null_transform
-            result = aln.get_similar(
-                aln.named_seqs[0],
-                min_similarity=0.5,
-                metric=metric,
-                transform=null_transform,
-            )
-        for seq in [0, 2]:
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 2)
-        # repeat with higher similarity
-        try:
-            result = aln.get_similar(
-                aln.named_seqs[0], min_similarity=0.8, metric=metric
-            )
-        except TypeError:  # need to coerce to RNA
-            result = aln.get_similar(
-                aln.named_seqs[0],
-                min_similarity=0.8,
-                metric=metric,
-                transform=null_transform,
-            )
-        for seq in [0]:
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 1)
-        # then, verify that the transform changes the results
-        result = aln.get_similar(
-            aln.named_seqs[0], min_similarity=0.5, metric=metric, transform=transform
-        )
-        for seq in [0, 1, 2]:
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 3)
-
-        result = aln.get_similar(
-            aln.named_seqs[0], min_similarity=0.8, metric=metric, transform=transform
-        )
-        for seq in [0, 1]:
-            self.assertIn(seq, result.named_seqs)
-            self.assertEqual(result.named_seqs[seq], aln.named_seqs[seq])
-        self.assertEqual(len(result.named_seqs), 2)
-
     def test_is_ragged(self):
         """SequenceCollection is_ragged should return true if ragged alignment"""
         assert not self.identical.is_ragged()
@@ -750,11 +434,6 @@ class SequenceCollectionBaseTests(object):
         aln = self.Class(["AAA", "CCC"])
         self.assertEqual(aln.to_fasta(), ">seq_0\nAAA\n>seq_1\nCCC\n")
 
-        # NOTE THE FOLLOWING SURPRISING BEHAVIOR BECAUSE OF THE TWO-ITEM
-        # SEQUENCE RULE:
-        aln = self.Class(["AA", "CC"])
-        self.assertEqual(aln.to_fasta(), ">A\nA\n>C\nC\n")
-
     def test_to_nexus(self):
         """SequenceCollection should return correct Nexus string format"""
         align_norm = self.Class(
@@ -790,16 +469,6 @@ class SequenceCollectionBaseTests(object):
         aln = self.Class({"seq1": "ACGU", "seq2": "CGUA", "seq3": "CCGU"})
         self.assertEqual(aln.num_seqs, 3)
 
-    def test_add(self):
-        """__add__ should concatenate sequence data, by name"""
-        align1 = self.Class({"a": "AAAA", "b": "TTTT", "c": "CCCC"})
-        align2 = self.Class({"a": "GGGG", "b": "----", "c": "NNNN"})
-        align = align1 + align2
-        concatdict = align.to_dict()
-        self.assertEqual(
-            concatdict, {"a": "AAAAGGGG", "b": "TTTT----", "c": "CCCCNNNN"}
-        )
-
     def test_add_info(self):
         """__add__ should preserve info attribute"""
         align1 = self.Class(
@@ -1045,30 +714,6 @@ class SequenceCollectionBaseTests(object):
         # assertRaises error when pad_length is less than max seq length
         self.assertRaises(ValueError, self.ragged_padded.pad_seqs, 5)
 
-    def test_to_moltype(self):
-        """correctly convert to specified moltype"""
-        data = {"seq1": "ACGTACGTA", "seq2": "ACCGAA---", "seq3": "ACGTACGTT"}
-        seqs = self.Class(data=data)
-        dna = seqs.to_moltype("dna")
-        self.assertEqual(dna.moltype.label, "dna")
-        rc = dna.rc().to_dict()
-        expect = {"seq1": "TACGTACGT", "seq2": "---TTCGGT", "seq3": "AACGTACGT"}
-        self.assertEqual(rc, expect)
-
-        data = {"seq1": "TTTTTTAAAA", "seq2": "AAAATTTTTT", "seq3": "AATTTTTAAA"}
-        seqs = self.Class(data=data)
-        rna = seqs.to_moltype("rna")
-        self.assertEqual(rna.moltype.label, "rna")
-        rc = rna.rc().to_dict()
-        expect = {"seq1": "UUUUAAAAAA", "seq2": "AAAAAAUUUU", "seq3": "UUUAAAAAUU"}
-        self.assertEqual(rc, expect)
-        # calling with a null object should raise an exception
-        with self.assertRaises(ValueError):
-            seqs.to_moltype(None)
-
-        with self.assertRaises(ValueError):
-            seqs.to_moltype("")
-
     def test_to_moltype_info(self):
         """correctly convert to specified moltype"""
         data = {"seq1": "ACGTACGTA", "seq2": "ACCGAA---", "seq3": "ACGTACGTT"}
@@ -1392,34 +1037,6 @@ class AlignmentBaseTests(SequenceCollectionBaseTests):
         )
         assert_allclose(got, expect)
 
-    def make_and_filter(self, raw, expected, motif_length, drop_remainder):
-        # a simple filter func
-        aln = self.Class(raw, info={"key": "value"})
-        func = _make_filter_func(aln)
-        result = aln.filtered(
-            func,
-            motif_length=motif_length,
-            log_warnings=False,
-            drop_remainder=drop_remainder,
-        )
-        self.assertEqual(result.to_dict(), expected)
-        self.assertEqual(result.info["key"], "value")
-
-    def test_filtered(self):
-        """filtered should return new alignment with positions consistent with
-        provided callback function"""
-        # a simple filter option
-        raw = {"a": "ACGACGACG", "b": "CCC---CCC", "c": "AAAA--AAA"}
-        self.make_and_filter(
-            raw, {"a": "ACGACG", "b": "CCCCCC", "c": "AAAAAA"}, 1, True
-        )
-        # check with motif_length = 2
-        self.make_and_filter(raw, {"a": "ACAC", "b": "CCCC", "c": "AAAA"}, 2, True)
-        # check with motif_length = 3
-        self.make_and_filter(
-            raw, {"a": "ACGACG", "b": "CCCCCC", "c": "AAAAAA"}, 3, True
-        )
-
     def test_filter_drop_remainder(self):
         """filter allows dropping"""
         raw = {"a": "ACGACGACG", "b": "CCC---CCC", "c": "AAAA--AAA"}
@@ -1445,20 +1062,6 @@ class AlignmentBaseTests(SequenceCollectionBaseTests):
             list(map(list, ["AAA", "AAA", "AAA", "A-A", "A--", "A--"])),
         )
 
-    def test_iter_positions(self):
-        # """SequenceCollection iter_positions() method should support reordering of #cols"""
-        r = self.Class(self.ragged_padded.named_seqs, names=["c", "b"])
-        self.assertEqual(
-            list(r.iter_positions(pos_order=[5, 1, 3])),
-            list(map(list, ["--", "AA", "A-"])),
-        )
-        # reorder names
-        r = self.Class(self.ragged_padded.named_seqs, names=["a", "b", "c"])
-        cols = list(r.iter_positions())
-        self.assertEqual(
-            cols, list(map(list, ["AAA", "AAA", "AAA", "A-A", "A--", "A--"]))
-        )
-
     def test_take_positions(self):
         """SequenceCollection take_positions should return new alignment w/ specified pos"""
         self.assertEqual(
@@ -1783,22 +1386,6 @@ class AlignmentBaseTests(SequenceCollectionBaseTests):
         obs = aln.entropy_per_pos()
         assert_allclose(obs, [0, 0, 0])
 
-    def test_sample(self):
-        """Alignment.sample should permute alignment by default"""
-        alignment = self.Class({"seq1": "ABCDEFGHIJKLMNOP", "seq2": "ABCDEFGHIJKLMNOP"})
-        # effectively permute columns, preserving length
-        shuffled = alignment.sample()
-        self.assertEqual(len(shuffled), len(alignment))
-        # ensure length correct
-        sample = alignment.sample(10)
-        self.assertEqual(len(sample), 10)
-        # test columns alignment preserved
-        seqs = list(sample.to_dict().values())
-        self.assertEqual(seqs[0], seqs[1])
-        # ensure each char occurs once as sampling without replacement
-        for char in seqs[0]:
-            self.assertEqual(seqs[0].count(char), 1)
-
     def test_sample_info(self):
         """Alignment.sample should preserver info attribute"""
         alignment = self.Class(
@@ -2024,42 +1611,6 @@ class AlignmentBaseTests(SequenceCollectionBaseTests):
         dna = aln.to_dna()
         self.assertEqual(dna.info["key"], "value")
 
-    def test_replace_seqs(self):
-        """replace_seqs should replace 1-letter w/ 3-letter seqs"""
-        a = self.Class({"seq1": "ACGU", "seq2": "C-UA", "seq3": "C---"})
-        seqs = {"seq1": "AAACCCGGGUUU", "seq2": "CCCUUUAAA", "seq3": "CCC"}
-        result = a.replace_seqs(seqs)  # default behaviour
-        self.assertEqual(
-            result.to_fasta(),
-            ">seq1\nAAACCCGGGUUU\n>seq2\nCCC---UUUAAA\n>seq3\nCCC---------\n",
-        )
-
-        result = a.replace_seqs(seqs, aa_to_codon=True)  # default behaviour
-        self.assertEqual(
-            result.to_fasta(),
-            ">seq1\nAAACCCGGGUUU\n>seq2\nCCC---UUUAAA\n>seq3\nCCC---------\n",
-        )
-
-        # should correctly gap the same sequences with same length
-        result = a.replace_seqs(a.degap(), aa_to_codon=False)  # default behaviour
-        self.assertEqual(
-            result.to_dict(), {"seq1": "ACGU", "seq2": "C-UA", "seq3": "C---"}
-        )
-
-        # should fail when not same length if aa_to_codon is False
-        new = SequenceCollection(
-            [(n, s.replace("-", "")) for n, s in list(a[:3].to_dict().items())]
-        )
-        self.assertRaises(ValueError, a.replace_seqs, new, aa_to_codon=False)
-
-        # check the gaps are changed
-        aln1 = self.Class(data={"a": "AC-CT", "b": "ACGCT"})
-        aln2 = self.Class(data={"a": "ACC-T", "b": "ACGCT"})
-
-        result = aln1.replace_seqs(aln2, aa_to_codon=False)
-        self.assertTrue(id(aln1) != id(aln2))
-        self.assertEqual(aln1.to_dict(), result.to_dict())
-
     def test_replace_seqs_info(self):
         """replace_seqs should preserve info attribute"""
         a = self.Class(
@@ -2094,32 +1645,6 @@ class AlignmentBaseTests(SequenceCollectionBaseTests):
         for k, v in expect.items():
             self.assertEqual(got[k], v)
 
-    def test_counts_per_seq(self):
-        """SequenceCollection.counts_per_seq handles motif length, allow_gaps etc.."""
-        data = {"a": "AAAA??????", "b": "CCCGGG--NN", "c": "CCGGTTCCAA"}
-        coll = self.Class(data=data, moltype="dna")
-        mtype = coll.moltype
-        got = coll.counts_per_seq()
-        self.assertEqual(got["a", "A"], 4)
-        self.assertEqual(len(got.motifs), len(mtype.alphabet))
-        got = coll.counts_per_seq(include_ambiguity=True, allow_gap=True)
-        # N, -, ? are the additional states
-        self.assertEqual(len(got.motifs), 7)
-        expect = {"-": 2, "?": 0, "A": 0, "C": 3, "G": 3, "N": 2, "T": 0}
-        b = got["b"].to_dict()
-        for k in expect:
-            self.assertEqual(b[k], expect[k])
-
-        got = coll.counts_per_seq(motif_length=2)
-        self.assertEqual(len(got.motifs), len(mtype.alphabet) ** 2)
-        self.assertEqual(got["a", "AA"], 2)
-        self.assertEqual(got["b", "GG"], 1)
-        got = coll.counts_per_seq(exclude_unobserved=True)
-        expect = {"C": 4, "G": 2, "T": 2, "A": 2}
-        c = got["c"].to_dict()
-        for k in expect:
-            self.assertEqual(c[k], expect[k])
-
     def test_counts_per_pos(self):
         """correctly count motifs"""
         exp = array(
@@ -2198,15 +1723,6 @@ class AlignmentBaseTests(SequenceCollectionBaseTests):
         self.assertTrue("-" not in found_motifs)
         self.assertEqual(lengths, {2})
 
-    def test_seq_entropy_just_gaps(self):
-        """ArrayAlignment get_seq_entropy should get entropy of each seq"""
-        a = self.Class(dict(a="A---", b="----"), moltype=DNA)
-        entropy = a.entropy_per_seq()
-        assert_allclose(entropy, [0, numpy.nan])
-        a = self.Class(dict(a="----", b="----"), moltype=DNA)
-        entropy = a.entropy_per_seq()
-        self.assertIs(entropy, None)
-
     def test_entropy_per_pos_just_gaps(self):
         """pos with just gaps have nan"""
         a = self.Class(dict(a="A---", b="C---", c="C---"), moltype=DNA)
@@ -2266,16 +1782,6 @@ class AlignmentBaseTests(SequenceCollectionBaseTests):
         aln = self.Class({"seq1": "--TTT?", "seq2": "GATC??"})
         self.assertEqual(str(aln.get_gapped_seq("seq1")), "--TTT?")
 
-    def test_count_gaps_per_pos(self):
-        """correctly compute the number of gaps"""
-        data = {"a": "AAAA---GGT", "b": "CCC--GG?GT"}
-        aln = self.Class(data=data, moltype=DNA)
-        # per position
-        got = aln.count_gaps_per_pos(include_ambiguity=False)
-        assert_equal(got.array, [0, 0, 0, 1, 2, 1, 1, 0, 0, 0])
-        got = aln.count_gaps_per_pos(include_ambiguity=True)
-        assert_equal(got.array, [0, 0, 0, 1, 2, 1, 1, 1, 0, 0])
-
     def test_count_gaps_per_seq(self):
         """correctly compute the number of gaps"""
         data = {"a": "AAAA---GGT", "b": "CCC--GG?GT"}
@@ -2550,81 +2056,6 @@ class AlignmentTests(AlignmentBaseTests, TestCase):
         gdrt = aln.get_degapped_relative_to("name1")
         self.assertEqual(gdrt.info["key"], "foo")
 
-    def test_add_from_ref_aln(self):
-        """should add or insert seqs based on align to reference"""
-        aln1 = self.Class(
-            [
-                ["name1", "-AC-DEFGHI---"],
-                ["name2", "XXXXXX--XXXXX"],
-                ["name3", "YYYY-YYYYYYYY"],
-            ]
-        )
-
-        aln2 = self.Class(
-            [
-                ["name1", "ACDEFGHI"],
-                ["name4", "KL--MNPR"],
-                ["name5", "KLACMNPR"],
-                ["name6", "KL--MNPR"],
-            ]
-        )
-
-        aligned_to_ref_out_aln_inserted = self.Class(
-            [
-                ["name1", "-AC-DEFGHI---"],
-                ["name4", "-KL---MNPR---"],
-                ["name5", "-KL-ACMNPR---"],
-                ["name6", "-KL---MNPR---"],
-                ["name2", "XXXXXX--XXXXX"],
-                ["name3", "YYYY-YYYYYYYY"],
-            ]
-        )
-
-        aln2_wrong_refseq = self.Class((("name1", "ACDXFGHI"), ("name4", "KL--MNPR")))
-
-        aln2_wrong_refseq_name = self.Class(
-            [["nameY", "ACDEFGHI"], ["name4", "KL--MNPR"]]
-        )
-
-        aln2_different_aln_class = ArrayAlignment(
-            [["name1", "ACDEFGHI"], ["name4", "KL--MNPR"]]
-        )
-
-        aln2_list = [["name1", "ACDEFGHI"], ["name4", "KL--MNPR"]]
-
-        aligned_to_ref_out_aln = self.Class(
-            [
-                ["name1", "-AC-DEFGHI---"],
-                ["name2", "XXXXXX--XXXXX"],
-                ["name3", "YYYY-YYYYYYYY"],
-                ["name4", "-KL---MNPR---"],
-            ]
-        )
-
-        out_aln = aln1.add_from_ref_aln(aln2, after_name="name1")
-        self.assertEqual(
-            str(aligned_to_ref_out_aln_inserted), str(out_aln)
-        )  # test insert_after
-
-        out_aln = aln1.add_from_ref_aln(aln2, before_name="name2")
-        self.assertEqual(aligned_to_ref_out_aln_inserted, out_aln)  # test insert_before
-
-        self.assertRaises(
-            ValueError, aln1.add_from_ref_aln, aln2_wrong_refseq_name
-        )  # test wrong_refseq_name
-
-        aln = aln1.add_from_ref_aln(aln2_different_aln_class)
-        self.assertEqual(
-            aligned_to_ref_out_aln, aln
-        )  # test_align_to_refseq_different_aln_class
-
-        aln = aln1.add_from_ref_aln(aln2_list)
-        self.assertEqual(aligned_to_ref_out_aln, aln)  # test from_list
-
-        self.assertRaises(
-            ValueError, aln1.add_from_ref_aln, aln2_wrong_refseq
-        )  # test wrong_refseq
-
     def test_deepcopy2(self):
         """ "Aligned.deepcopy correctly handles gapped sequences"""
         seqs = self.Class(
@@ -2684,41 +2115,21 @@ class ArrayAlignmentSpecificTests(TestCase):
 
     def setUp(self):
         """Define some standard alignments."""
-        self.a = ArrayAlignment(
-            array([[0, 1, 2], [3, 4, 5]]), conversion_f=aln_from_array
-        )
         self.a2 = ArrayAlignment(["ABC", "DEF"], names=["x", "y"])
         seqs = []
         for s in ["abaa", "abbb"]:
             seqs.append(AB.make_seq(s, preserve_case=True))
-        self.a = ArrayAlignment(seqs, alphabet=AB.alphabet)
+        self.a = ArrayAlignment(seqs, moltype=AB)
         self.b = Alignment(["ABC", "DEF"])
         self.c = SequenceCollection(["ABC", "DEF"])
 
     def test_init(self):
         """ArrayAlignment init should work from a sequence"""
-        a = ArrayAlignment(array([[0, 1, 2], [3, 4, 5]]), conversion_f=aln_from_array)
+        a = ArrayAlignment(array([[0, 1, 2], [3, 4, 5]]).T)
         assert_equal(a.seq_data, array([[0, 3], [1, 4], [2, 5]], "B"))
         assert_equal(a.array_positions, array([[0, 1, 2], [3, 4, 5]], "B"))
         assert_equal(a.names, ["seq_0", "seq_1", "seq_2"])
 
-    def test_guess_input_type(self):
-        """ArrayAlignment _guess_input_type should figure out data type correctly"""
-        git = self.a._guess_input_type
-        self.assertEqual(git(self.a), "array_aln")
-        self.assertEqual(git(self.b), "aln")
-        self.assertEqual(git(self.c), "collection")
-        self.assertEqual(git(">ab\nabc"), "fasta")
-        self.assertEqual(git([">ab", "abc"]), "fasta")
-        self.assertEqual(git(["abc", "def"]), "generic")
-        # precedence over generic
-        self.assertEqual(git([[1, 2], [4, 5]]), "kv_pairs")
-        self.assertEqual(git([[1, 2, 3], [4, 5, 6]]), "generic")
-        self.assertEqual(git([ArraySequence("abc")]), "array_seqs")
-        self.assertEqual(git(array([[1, 2, 3], [4, 5, 6]])), "array")
-        self.assertEqual(git({"a": "aca"}), "dict")
-        self.assertEqual(git([]), "empty")
-
     def test_init_seqs(self):
         """ArrayAlignment init should work from ArraySequence objects."""
         s = list(map(ArraySequence, ["abc", "def"]))
@@ -2746,43 +2157,6 @@ class ArrayAlignmentSpecificTests(TestCase):
         assert_equal(a.seq_data, array(["AAACCC", "GCGCGC"], "c").view("B"))
         self.assertEqual(tuple(a.names), ("abc", "xyz"))
 
-    def test_init_empty(self):
-        """ArrayAlignment init should fail if empty."""
-        self.assertRaises(TypeError, ArrayAlignment)
-        self.assertRaises(ValueError, ArrayAlignment, 3)
-
-    def test_get_alphabet_and_moltype(self):
-        """ArrayAlignment should figure out correct alphabet and moltype"""
-        s1 = "A"
-        s2 = RNA.make_seq("AA")
-
-        d = ArrayAlignment(s1)
-        self.assertIs(d.moltype, BYTES)
-        self.assertIs(d.alphabet, BYTES.alphabet)
-
-        d = ArrayAlignment(s1, moltype=RNA)
-        self.assertIs(d.moltype, RNA)
-        self.assertIs(d.alphabet, RNA.alphabets.degen_gapped)
-
-        d = ArrayAlignment(s1, alphabet=RNA.alphabet)
-        self.assertIs(d.moltype, RNA)
-        self.assertIs(d.alphabet, RNA.alphabet)
-
-        d = ArrayAlignment(s2)
-        self.assertIs(d.moltype, RNA)
-        self.assertIs(d.alphabet, RNA.alphabets.degen_gapped)
-
-        d = ArrayAlignment(s2, moltype=DNA)
-        self.assertIs(d.moltype, DNA)
-        self.assertIs(d.alphabet, DNA.alphabets.degen_gapped)
-        # checks for containers
-        d = ArrayAlignment([s2])
-        self.assertIs(d.moltype, RNA)
-        d = ArrayAlignment({"x": s2})
-        self.assertIs(d.moltype, RNA)
-        d = ArrayAlignment(set([s2]))
-        self.assertIs(d.moltype, RNA)
-
     def test_iter(self):
         """ArrayAlignment iter should iterate over positions"""
         result = list(iter(self.a2))
@@ -2801,40 +2175,40 @@ class ArrayAlignmentSpecificTests(TestCase):
 
     def test_get_sub_alignment(self):
         """ArrayAlignment get_sub_alignment should get requested part of alignment"""
-        a = ArrayAlignment(">x ABCE >y FGHI >z JKLM".split())
+        a = ArrayAlignment({"x": "ABCE", "y": "FGHI", "z": "JKLM"})
         # passing in positions should keep all seqs, but just selected
         # positions
-        b = ArrayAlignment(">x BC >y GH >z KL".split())
+        b = ArrayAlignment({"x": "BC", "y": "GH", "z": "KL"})
         a_1 = a.get_sub_alignment(pos=[1, 2])
         self.assertEqual(a_1.names, b.names)
 
         self.assertEqual(a_1.seqs, b.seqs)
-        # ...and with invert_pos, should keep all except the positions passed in
-        a_2 = a.get_sub_alignment(pos=[0, 3], invert_pos=True)
+        # ...and with negate_pos, should keep all except the positions passed in
+        a_2 = a.get_sub_alignment(pos=[0, 3], negate_pos=True)
         self.assertEqual(a_2.seqs, b.seqs)
         self.assertEqual(a_2.names, b.names)
         # passing in seqs should keep all positions, but just selected seqs
-        c = ArrayAlignment(">x ABCE >z JKLM".split())
+        c = ArrayAlignment({"x": "ABCE", "z": "JKLM"})
         a_3 = a.get_sub_alignment(seqs=[0, 2])
         self.assertEqual(a_3.seqs, c.seqs)
         # check that labels were updates as well...
         self.assertEqual(a_3.names, c.names)
-        # ...and should work with invert_seqs to exclude just selected seqs
-        a_4 = a.get_sub_alignment(seqs=[1], invert_seqs=True)
+        # ...and should work with negate_seqs to exclude just selected seqs
+        a_4 = a.get_sub_alignment(seqs=[1], negate_seqs=True)
         self.assertEqual(a_4.seqs, c.seqs)
         self.assertEqual(a_4.names, c.names)
         # should be able to do both seqs and positions simultaneously
-        d = ArrayAlignment(">x BC >z KL".split())
+        d = ArrayAlignment({"x": "BC", "z": "KL"})
         a_5 = a.get_sub_alignment(seqs=[0, 2], pos=[1, 2])
         self.assertEqual(a_5.seqs, d.seqs)
         self.assertEqual(a_5.names, d.names)
 
     def test_get_sub_alignment_info(self):
         """ArrayAlignment get_sub_alignment should preserve info attribute"""
-        a = ArrayAlignment(">x ABCE >y FGHI >z JKLM".split(), info={"key": "foo"})
+        a = ArrayAlignment({"x": "ABCE", "y": "FGHI", "z": "JKLM"}, info={"key": "foo"})
         # passing in positions should keep all seqs, but just selected
         # positions
-        b = ArrayAlignment(">x BC >y GH >z KL".split(), info={"key": "bar"})
+        b = ArrayAlignment({"x": "BC", "y": "GH", "z": "KL"}, info={"key": "bar"})
         a_1 = a.get_sub_alignment(pos=[1, 2])
         self.assertEqual(a_1.names, b.names)
         self.assertEqual(a.info["key"], "foo")
@@ -2846,14 +2220,6 @@ class ArrayAlignmentSpecificTests(TestCase):
         self.a2.names[-1] = "yyy"
         self.assertEqual(str(self.a2), ">x\nABC\n>yyy\nDEF\n")
 
-    def test_counts_per_seq(self):
-        """ArrayAlignment counts_per_seq should return motif counts each seq"""
-        a = self.a
-        f = a.counts_per_seq()
-        assert_equal(f.array, array([[3, 1], [1, 3]]))
-        f = a.counts_per_seq(motif_length=2, exclude_unobserved=True)
-        assert_equal(f.array, array([[1, 1, 0], [0, 1, 1]]))
-
     def test_entropy_per_pos(self):
         """entropy_per_pos should get entropy of each pos"""
         a = self.a
@@ -2906,14 +2272,6 @@ class ArrayAlignmentSpecificTests(TestCase):
         ]
         assert_allclose(f, e)
 
-    def test_coevolution_segments(self):
-        """specifying coordinate segments produces matrix with just those"""
-        aln = load_aligned_seqs("data/brca1.fasta", moltype="dna")
-        aln = aln.take_seqs(aln.names[:20])
-        aln = aln.no_degenerates()[:20]
-        coevo = aln.coevolution(segments=[(4, 6), (11, 13)], show_progress=False)
-        self.assertEqual(coevo.template.names[0], [4, 5, 11, 12])
-
 
 class IntegrationTests(TestCase):
     """Test for integration between regular and model seqs and alns"""
@@ -2928,9 +2286,9 @@ class IntegrationTests(TestCase):
     def test_model_to_model(self):
         """Model seq should work with dense alignment"""
         a = ArrayAlignment([self.m1, self.m2])
-        self.assertEqual(str(a), ">xx\nAAA\n>yy\nCCC\n")
+        self.assertEqual(a.to_dict(), {"xx": "AAA", "yy": "CCC"})
         a = ArrayAlignment([self.m1, self.m2], moltype=DNA)
-        self.assertEqual(str(a), ">xx\nAAA\n>yy\nCCC\n")
+        self.assertEqual(a.to_dict(), {"xx": "AAA", "yy": "CCC"})
         self.assertEqual(self.m1.name, "xx")
 
     def test_regular_to_model(self):
@@ -3405,7 +2763,7 @@ def test_dotplot_annotated(cls):
 def test_get_seq_entropy(cls):
     """ArrayAlignment get_seq_entropy should get entropy of each seq"""
     seqs = [AB.make_seq(s, preserve_case=True) for s in ["abab", "bbbb", "abbb"]]
-    a = cls(seqs, alphabet=AB.alphabet)
+    a = cls(seqs, moltype=AB)
     entropy = a.entropy_per_seq()
     e = 0.81127812445913283  # sum(p log_2 p) for p = 0.25, 0.75
     assert_allclose(entropy, array([1, 0, e]))
@@ -3820,12 +3178,40 @@ def test_init_duplicate_keys_raises(cls):
         cls(data)
 
 
-@pytest.mark.parametrize("cls", (SequenceCollection, Alignment, ArrayAlignment))
-def test_init_duplicate_keys_merged(cls):
-    data = [["x", "XXX"], ["b", "BBB"], ["x", "CCC"], ["d", "DDD"], ["a", "AAA"]]
-    seqs = cls(data, remove_duplicate_names=True)
-    # the first record encountered is the one retained
-    assert seqs.to_dict()["x"] == dict(reversed(data))["x"]
+@pytest.mark.parametrize(
+    "seq",
+    (
+        "ACGG",
+        DNA.make_seq("ACGG"),
+        numpy.array([2, 1, 3, 3], dtype=int),
+        Aligned(*DNA.make_seq("AC-GG").parse_out_gaps()),
+    ),
+)
+def test_construct_unaligned_seq(seq):
+    moltype = get_moltype("dna")
+    got = _construct_unaligned_seq(seq, moltype=moltype)
+    assert isinstance(got, (Sequence, ArraySequence))
+
+
+@pytest.mark.parametrize(
+    "data",
+    (
+        [["s1", "ACGG"]],
+        {"s1": "ACGG"},
+        {"s1": DNA.make_seq("ACGG")},
+        (
+            Aligned(
+                *DNA.make_seq("AC-GG", name="s1").parse_out_gaps(),
+            ),
+        ),
+        iter([["s1", "ACGG"]]),
+    ),
+)
+def test_to_unaligned_seqs(data):
+    moltype = get_moltype("dna")
+    got = _coerce_to_unaligned_seqs(data, names=None, moltype=moltype)
+    assert isinstance(got[0], list)
+    assert isinstance(got[0][0], (Sequence, ArraySequence))
 
 
 @pytest.mark.parametrize("moltype", ("dna", "protein"))
@@ -3836,3 +3222,310 @@ def test_same_moltype(cls, moltype):
     seqs = cls(data, moltype=moltype)
     got = seqs.to_moltype(moltype=moltype)
     assert got is seqs
+
+
+@pytest.mark.parametrize("cls", (SequenceCollection, Alignment, ArrayAlignment))
+def test_add(cls):
+    """__add__ should concatenate sequence data, by name"""
+    align1 = cls({"a": "AAAA", "b": "TTTT", "c": "CCCC"})
+    align2 = cls({"a": "GGGG", "b": "----", "c": "NNNN"})
+    align = align1 + align2
+    concatdict = align.to_dict()
+    assert concatdict == {"a": "AAAAGGGG", "b": "TTTT----", "c": "CCCCNNNN"}
+
+
+@pytest.mark.parametrize("cls", (Alignment, ArrayAlignment))
+def test_count_gaps_per_pos(cls):
+    """correctly compute the number of gaps"""
+    data = {"a": "AAAA---GGT", "b": "CCC--GG?GT"}
+    aln = cls(data=data, moltype=DNA)
+    # per position
+    got = aln.count_gaps_per_pos(include_ambiguity=False)
+    assert_equal(got.array, [0, 0, 0, 1, 2, 1, 1, 0, 0, 0])
+    got = aln.count_gaps_per_pos(include_ambiguity=True)
+    assert_equal(got.array, [0, 0, 0, 1, 2, 1, 1, 1, 0, 0])
+
+
+def _make_and_filter(cls, raw, expected, motif_length, drop_remainder):
+    # a simple filter func
+    aln = cls(raw, info={"key": "value"})
+    func = _make_filter_func(aln)
+    result = aln.filtered(
+        func,
+        motif_length=motif_length,
+        log_warnings=False,
+        drop_remainder=drop_remainder,
+    )
+    assert result.to_dict() == expected
+    assert result.info["key"] == "value"
+
+
+@pytest.mark.parametrize("cls", (Alignment, ArrayAlignment))
+def test_filtered(cls):
+    """filtered should return new alignment with positions consistent with
+    provided callback function"""
+    # a simple filter option
+    raw = {"a": "ACGACGACG", "b": "CCC---CCC", "c": "AAAA--AAA"}
+    _make_and_filter(cls, raw, {"a": "ACGACG", "b": "CCCCCC", "c": "AAAAAA"}, 1, True)
+    # check with motif_length = 2
+    _make_and_filter(cls, raw, {"a": "ACAC", "b": "CCCC", "c": "AAAA"}, 2, True)
+    # check with motif_length = 3
+    _make_and_filter(cls, raw, {"a": "ACGACG", "b": "CCCCCC", "c": "AAAAAA"}, 3, True)
+
+
+@pytest.mark.parametrize("cls", (SequenceCollection, Alignment, ArrayAlignment))
+def test_counts_per_seq(cls):
+    """SequenceCollection.counts_per_seq handles motif length, allow_gaps etc.."""
+    data = {"a": "AAAA??????", "b": "CCCGGG--NN", "c": "CCGGTTCCAA"}
+    coll = cls(data=data, moltype="dna")
+    mtype = coll.moltype
+    got = coll.counts_per_seq()
+    assert got["a", "A"] == 4
+    assert len(got.motifs) == len(mtype.alphabet)
+    got = coll.counts_per_seq(include_ambiguity=True, allow_gap=True)
+    # N, -, ? are the additional states
+    assert len(got.motifs) == 7
+    expect = {"-": 2, "?": 0, "A": 0, "C": 3, "G": 3, "N": 2, "T": 0}
+    b = got["b"].to_dict()
+    for k in expect:
+        assert b[k] == expect[k]
+
+    got = coll.counts_per_seq(motif_length=2)
+    assert len(got.motifs), len(mtype.alphabet) ** 2
+    assert got["a", "AA"] == 2
+    assert got["b", "GG"] == 1
+    got = coll.counts_per_seq(exclude_unobserved=True)
+    expect = {"C": 4, "G": 2, "T": 2, "A": 2}
+    c = got["c"].to_dict()
+    for k in expect:
+        assert c[k] == expect[k]
+
+
+def test_counts_per_seq_arr_alignment():
+    """ArrayAlignment counts_per_seq should return motif counts each seq"""
+    seqs = []
+    for s in ["abaa", "abbb"]:
+        seqs.append(AB.make_seq(s, preserve_case=True))
+    a = ArrayAlignment(seqs, moltype=AB)
+    f = a.counts_per_seq()
+    assert_equal(f.array, array([[3, 1], [1, 3]]))
+    f = a.counts_per_seq(motif_length=2, exclude_unobserved=True)
+    assert_equal(f.array, array([[1, 1, 0], [0, 1, 1]]))
+
+
+def test_coevolution_segments():
+    """specifying coordinate segments produces matrix with just those"""
+    aln = load_aligned_seqs("data/brca1.fasta", moltype="dna")
+    aln = aln.take_seqs(aln.names[:20])
+    aln = aln.no_degenerates()[:20]
+    coevo = aln.coevolution(segments=[(4, 6), (11, 13)], show_progress=False)
+    assert coevo.template.names[0] == [4, 5, 11, 12]
+
+
+@pytest.mark.parametrize("cls", (Alignment, ArrayAlignment))
+def test_iter_positions(cls):
+    data = {"a": "AAAAAA", "b": "AAA---", "c": "AAAA--"}
+    r = cls({k: data[k] for k in "cb"})
+    assert list(r.iter_positions(pos_order=[5, 1, 3])) == list(
+        map(list, ["--", "AA", "A-"])
+    )
+    # reorder names
+    r = cls(data)
+    cols = list(r.iter_positions())
+    assert cols == list(map(list, ["AAA", "AAA", "AAA", "A-A", "A--", "A--"]))
+
+
+@pytest.mark.parametrize("cls", (Alignment, ArrayAlignment))
+def test_add_from_ref_aln(cls):
+    """should add or insert seqs based on align to reference"""
+    aln1 = cls(
+        [
+            ["name1", "-AC-DEFGHI---"],
+            ["name2", "XXXXXX--XXXXX"],
+            ["name3", "YYYY-YYYYYYYY"],
+        ]
+    )
+
+    aln2 = cls(
+        [
+            ["name1", "ACDEFGHI"],
+            ["name4", "KL--MNPR"],
+            ["name5", "KLACMNPR"],
+            ["name6", "KL--MNPR"],
+        ]
+    )
+
+    aligned_to_ref_out_aln_inserted = cls(
+        [
+            ["name1", "-AC-DEFGHI---"],
+            ["name4", "-KL---MNPR---"],
+            ["name5", "-KL-ACMNPR---"],
+            ["name6", "-KL---MNPR---"],
+            ["name2", "XXXXXX--XXXXX"],
+            ["name3", "YYYY-YYYYYYYY"],
+        ]
+    )
+
+    aln2_wrong_refseq = cls((("name1", "ACDXFGHI"), ("name4", "KL--MNPR")))
+
+    aln2_wrong_refseq_name = cls([["nameY", "ACDEFGHI"], ["name4", "KL--MNPR"]])
+
+    aln2_different_aln_class = ArrayAlignment(
+        [["name1", "ACDEFGHI"], ["name4", "KL--MNPR"]]
+    )
+
+    aligned_to_ref_out_aln = cls(
+        [
+            ["name1", "-AC-DEFGHI---"],
+            ["name2", "XXXXXX--XXXXX"],
+            ["name3", "YYYY-YYYYYYYY"],
+            ["name4", "-KL---MNPR---"],
+        ]
+    )
+
+    out_aln = aln1.add_from_ref_aln(aln2, after_name="name1")
+    assert str(aligned_to_ref_out_aln_inserted) == str(out_aln)  # test insert_after
+
+    out_aln = aln1.add_from_ref_aln(aln2, before_name="name2")
+    assert aligned_to_ref_out_aln_inserted == out_aln  # test insert_before
+
+    with pytest.raises(ValueError):
+        aln1.add_from_ref_aln(aln2_wrong_refseq_name)
+
+    aln = aln1.add_from_ref_aln(aln2_different_aln_class)
+    # test_align_to_refseq_different_aln_class
+    assert aligned_to_ref_out_aln == aln
+
+    with pytest.raises(ValueError):
+        # test wrong_refseq
+        aln1.add_from_ref_aln(aln2_wrong_refseq)
+
+
+@pytest.mark.parametrize("cls", (Alignment, ArrayAlignment))
+def test_replace_seqs(cls):
+    """replace_seqs should replace 1-letter w/ 3-letter seqs"""
+    a = cls({"seq1": "ACGU", "seq2": "C-UA", "seq3": "C---"})
+    seqs = {"seq1": "AAACCCGGGUUU", "seq2": "CCCUUUAAA", "seq3": "CCC"}
+    result = a.replace_seqs(seqs)  # default behaviour
+    assert result.to_dict() == {
+        "seq1": "AAACCCGGGUUU",
+        "seq2": "CCC---UUUAAA",
+        "seq3": "CCC---------",
+    }
+
+    result = a.replace_seqs(seqs, aa_to_codon=True)  # default behaviour
+    assert result.to_dict() == {
+        "seq1": "AAACCCGGGUUU",
+        "seq2": "CCC---UUUAAA",
+        "seq3": "CCC---------",
+    }
+
+    # should correctly gap the same sequences with same length
+    result = a.replace_seqs(a.degap(), aa_to_codon=False)  # default behaviour
+    assert result.to_dict() == {"seq1": "ACGU", "seq2": "C-UA", "seq3": "C---"}
+
+    # should fail when not same length if aa_to_codon is False
+    new = SequenceCollection(
+        [(n, s.replace("-", "")) for n, s in list(a[:3].to_dict().items())],
+        moltype="bytes",
+    )
+    with pytest.raises(ValueError):
+        a.replace_seqs(new, aa_to_codon=False)
+
+    # check the gaps are changed
+    aln1 = cls(data={"a": "AC-CT", "b": "ACGCT"})
+    aln2 = cls(data={"a": "ACC-T", "b": "ACGCT"})
+
+    result = aln1.replace_seqs(aln2, aa_to_codon=False)
+    assert id(aln1) != id(aln2)
+    assert aln1.to_dict() == result.to_dict()
+
+
+def test_get_alphabet_and_moltype():
+    """ArrayAlignment should figure out correct alphabet and moltype"""
+    s1 = "A"
+    s2 = RNA.make_seq("AA")
+
+    d = ArrayAlignment(s1)
+    assert d.moltype is BYTES
+    assert d.alphabet is BYTES.alphabet
+
+    d = ArrayAlignment(s1, moltype=RNA)
+    assert d.moltype is RNA
+    assert d.alphabet is RNA.alphabets.degen_gapped
+
+    d = ArrayAlignment([s2])
+    assert d.moltype is RNA
+    assert d.alphabet is RNA.alphabets.degen_gapped
+
+    d = ArrayAlignment(s2, moltype=DNA)
+    assert d.moltype is DNA
+    assert d.alphabet is DNA.alphabets.degen_gapped
+    # checks for containers
+    d = ArrayAlignment([s2])
+    assert d.moltype is RNA
+    d = ArrayAlignment({"x": s2})
+    assert d.moltype is RNA
+    d = ArrayAlignment(set([s2]))
+    assert d.moltype is RNA
+
+
+@pytest.mark.parametrize("cls", (Alignment, ArrayAlignment, SequenceCollection))
+def test_aln_from_fasta_parser(cls):
+    """aln_from_fasta_parser should init from iterator"""
+    s = ">aa\nAC\n>bb\nAA\n>c\nGG\n".splitlines()
+    p = MinimalFastaParser(s)
+    aln = cls(p, moltype=DNA)
+    assert aln.named_seqs["aa"] == "AC"
+    assert aln.to_dict() == {"aa": "AC", "bb": "AA", "c": "GG"}
+    s2 = ">aa\nAC\n>bb\nAA\n>c\nGG\n"
+    d = cls(MinimalFastaParser(s2.splitlines()))
+    assert d.to_dict() == aln.to_dict()
+
+
+@pytest.mark.parametrize(
+    "d", ({"a": "AAAAA", "b": "BBBBB"}, {"a": b"AAAAA", "b": b"BBBBB"})
+)
+@pytest.mark.parametrize("cls", (Alignment, ArrayAlignment, SequenceCollection))
+def test_init_dict(cls, d):
+    """SequenceCollection init from dict should work as expected"""
+    # from bytes strings
+    a = cls(d, names=["a", "b"])
+    expect = {k: v.decode("utf8") if isinstance(v, bytes) else v for k, v in d.items()}
+    assert a.to_dict() == expect
+
+
+@pytest.mark.parametrize("cls", (Alignment, ArrayAlignment, SequenceCollection))
+def test_init_seq_info(cls):
+    """SequenceCollection init from seqs w/ info should preserve data"""
+    a = Sequence("AAA", name="a", info={"x": 3})
+    b = Sequence("CCC", name="b", info={"x": 4})
+    c = Sequence("GGG", name="c", info={"x": 5})
+    seqs = [c, b, a]
+    a = cls(seqs)
+    assert list(a.names) == ["c", "b", "a"]
+    assert list(map(str, a.seqs)) == ["GGG", "CCC", "AAA"]
+    if cls is not ArrayAlignment:
+        # ArrayAlignment is allowed to strip info objects
+        assert [i.info.x for i in a.seqs] == [5, 4, 3]
+    # check it still works if constructed from same class
+    b = cls(a)
+    assert list(b.names) == ["c", "b", "a"]
+    assert list(map(str, b.seqs)) == ["GGG", "CCC", "AAA"]
+    if cls is not ArrayAlignment:
+        # ArrayAlignment is allowed to strip Info objects
+        assert [i.info.x for i in b.seqs] == [5, 4, 3]
+
+
+@pytest.mark.parametrize("val", (None, 3))
+def test_init_empty(val):
+    """ArrayAlignment init should fail if empty."""
+    with pytest.raises((ValueError, TypeError)):
+        ArrayAlignment(val)
+        ArrayAlignment()
+
+
+def test_make_case():
+    data = {"a": "tata", "b": "tgtc", "c": "gcga", "d": "gaac", "e": "gagc"}
+    got = make_aligned_seqs(data=data, moltype="dna")
+    assert got == {k: v.upper() for k, v in data.items()}
diff --git a/tests/test_core/test_seq_aln_integration.py b/tests/test_core/test_seq_aln_integration.py
index f3ab2f685..ef505e63a 100644
--- a/tests/test_core/test_seq_aln_integration.py
+++ b/tests/test_core/test_seq_aln_integration.py
@@ -30,7 +30,6 @@ class AllTests(TestCase):
         self.da = ArrayAlignment(
             [self.model1, self.model2, self.model3],
             moltype=RNA,
-            alphabet=RNA.alphabets.degen_gapped,
         )
 
         # seqs no name
@@ -46,7 +45,6 @@ class AllTests(TestCase):
         self.nn_da = ArrayAlignment(
             [self.nn_model1, self.nn_model2, self.nn_model3],
             moltype=RNA,
-            alphabet=RNA.alphabets.degen_gapped,
         )
 
     def test_printing_named_seqs(self):
@@ -117,7 +115,8 @@ class AllTests(TestCase):
         model2 = ArraySequence("YCG", name="rna2", alphabet=RNA.alphabets.degen_gapped)
         model3 = ArraySequence("CAR", name="rna3", alphabet=RNA.alphabets.degen_gapped)
         sub_da = ArrayAlignment(
-            [model1, model2, model3], moltype=RNA, alphabet=RNA.alphabets.degen_gapped
+            [model1, model2, model3],
+            moltype=RNA,
         )
 
         sub_data = array([[0, 1, 3], [Y, 1, 3], [1, 2, R]])
@@ -192,7 +191,8 @@ class AllTests(TestCase):
         model2 = ArraySequence("YCG", name="rna2", alphabet=RNA.alphabets.degen_gapped)
         model3 = ArraySequence("CAR", name="rna3", alphabet=RNA.alphabets.degen_gapped)
         sub_da = ArrayAlignment(
-            [model1, model2, model3], moltype=RNA, alphabet=RNA.alphabets.degen_gapped
+            [model1, model2, model3],
+            moltype=RNA,
         )
 
         # take_seqs by name should have the same effect as
@@ -209,14 +209,14 @@ class AllTests(TestCase):
         self.assertEqual(self.da == self.da, True)
         # one sequence less
         other_da1 = ArrayAlignment(
-            [self.model1, self.model2], moltype=RNA, alphabet=RNA.alphabets.degen_gapped
+            [self.model1, self.model2],
+            moltype=RNA,
         )
         self.assertEqual(self.da == other_da1, False)
         # seqs in different order -- doesn't matter
         other_da2 = ArrayAlignment(
             [self.model1, self.model3, self.model2],
             moltype=RNA,
-            alphabet=RNA.alphabets.degen_gapped,
         )
         self.assertEqual(self.da == other_da2, True)
         # seqs in different encoding -- doesn't matter, only looks at data
diff --git a/tests/test_evolve/test_coevolution.py b/tests/test_evolve/test_coevolution.py
index 9a14252de..e05dc8fb9 100755
--- a/tests/test_evolve/test_coevolution.py
+++ b/tests/test_evolve/test_coevolution.py
@@ -92,6 +92,11 @@ from cogent3.evolve.coevolution import (
     validate_tree,
 )
 from cogent3.maths.stats.number import CategoryCounter
+from cogent3.parse.fasta import MinimalFastaParser
+
+
+def _fasta_to_dict(data):
+    return dict(MinimalFastaParser(data.splitlines()))
 
 
 class CoevolutionTests(TestCase):
@@ -5294,7 +5299,8 @@ EEMKVDQFGPGHTTLPGELAPDSEPELIDSTKLIEVQVVLILAYCSIILLGVIGNSLVIHVVIKFKSMRTVTNFFIANLA
 >HH1R_RAT
 ----------MSFANTSSTFEDKMCEGNRTAMASPQLLPLVVVLSSISLVTVGLNLLVLYAVHSERKLHTVGNLYIVSLSVADLIVGAVVMPMNILYLIMTKWSLGRPLCLFWLSMDYVASTASIFSVFILCIDRYRSVQQPLYLRYRTKTRASATILGAWFFSFLWVIPILGWHHFM--EL-EDKCETD------FYNVTWFKIMTAIINFYLPTLLMLWFYVKIYKAVRRHLRSQYVSGLHLNRERKAAKQLGFIMAAFILCWIPYFIFFMVIAFCKSC-CSEPMHMFTIWLGYINSTLNPLIYPLCNENFKKTFKKILHIRS-----------------------"""
 
-gpcr_aln = ArrayAlignment(data=gpcr_ungapped.split("\n"), moltype=PROTEIN)
+
+gpcr_aln = ArrayAlignment(data=_fasta_to_dict(gpcr_ungapped), moltype=PROTEIN)
 
 myos_data = """>gi|107137|pir||A37102
 LSRIITRIQA
@@ -5525,10 +5531,7 @@ LAQLITRTQA
 >gi|9971579|dbj|BAB12571.1|
 LAALVTMTQA"""
 
-myos_aln = ArrayAlignment(data=myos_data.split("\n"), moltype=PROTEIN)
+myos_aln = ArrayAlignment(data=_fasta_to_dict(myos_data), moltype=PROTEIN)
 
 # a randomly generated tree to use in tests
 tree20_string = "(((0:0.5,1:0.5):0.5,(((2:0.5,3:0.5):0.5,(4:0.5,(5:0.5,6:0.5):0.5):0.5):0.5,((7:0.5,8:0.5):0.5,((9:0.5,((10:0.5,11:0.5):0.5,12:0.5):0.5):0.5,13:0.5):0.5):0.5):0.5):0.5,(((14:0.5,(15:0.5,16:0.5):0.5):0.5,17:0.5):0.5,(18:0.5,19:0.5):0.5):0.5);"
-
-if __name__ == "__main__":
-    main()
diff --git a/tests/test_evolve/test_likelihood_function.py b/tests/test_evolve/test_likelihood_function.py
index a232d245d..0a3d8acc3 100644
--- a/tests/test_evolve/test_likelihood_function.py
+++ b/tests/test_evolve/test_likelihood_function.py
@@ -515,7 +515,7 @@ DogFaced   root      1.00  1.00
 
     def test_simulate_alignment2(self):
         "Simulate alignment with dinucleotide model"
-        al = make_aligned_seqs(data={"a": "ggaatt", "c": "cctaat"})
+        al = make_aligned_seqs(data={"a": "ggaatt", "c": "cctaat"}, moltype="dna")
         t = make_tree("(a,c);")
         sm = substitution_model.TimeReversibleDinucleotide(mprob_model="tuple")
         lf = sm.make_likelihood_function(t)
@@ -527,7 +527,7 @@ DogFaced   root      1.00  1.00
         """provide a root sequence for simulating an alignment"""
 
         def use_root_seq(root_sequence):
-            al = make_aligned_seqs(data={"a": "ggaatt", "c": "cctaat"})
+            al = make_aligned_seqs(data={"a": "ggaatt", "c": "cctaat"}, moltype="dna")
             t = make_tree(treestring="(a,c);")
             sm = substitution_model.TimeReversibleDinucleotide(mprob_model="tuple")
             lf = sm.make_likelihood_function(t)
@@ -772,7 +772,7 @@ DogFaced     root      1.0000    1.0000
 
     def test_exercise_set_align(self):
         "lf.set_align should work for different models"
-        al = make_aligned_seqs(data={"a": "ggaatt", "c": "cctaat"})
+        al = make_aligned_seqs(data={"a": "ggaatt", "c": "cctaat"}, moltype="dna")
         t = make_tree(treestring="(a,c);")
         for klass in [CNFGTR, Y98, MG94HKY]:
             sm = klass()
@@ -2243,10 +2243,10 @@ def test_simulate_alignment3():
     t = make_tree(treestring="(a:0.4,b:0.3,(c:0.15,d:0.2)edge.0:0.1)root;")
     al = make_aligned_seqs(
         data={
-            "a": "g--cactat?",
-            "b": "---c-ctcct",
-            "c": "-a-c-ctat-",
-            "d": "-a-c-ctat-",
+            "a": "G--CACTAT?",
+            "b": "---C-CTCCT",
+            "c": "-A-C-CTAT-",
+            "d": "-A-C-CTAT-",
         }
     )
     sm = TimeReversibleNucleotide(recode_gaps=True)
diff --git a/tests/test_evolve/test_ns_substitution_model.py b/tests/test_evolve/test_ns_substitution_model.py
index ba392650c..d7dfb0fb0 100644
--- a/tests/test_evolve/test_ns_substitution_model.py
+++ b/tests/test_evolve/test_ns_substitution_model.py
@@ -44,13 +44,11 @@ def _make_likelihood(model, tree, results, is_discrete=False):
     return lf
 
 
-_aln = """>Human
-ATGCGGCTCGCGGAGGAGCGGGCCGCGCTC------GCGGCGGAGAACGCGGATGGGGAACCCGGC---GCCGACCGACGACTGCGACTCCTGGGGACCTACGTGGCCATGAGCCTGCGGCCGGCTGCGGGCGCCTGGGAGCGTTGCGCGGGGAGTGCTGAGGCGGAGCAGCTGCTCCAGGCCTTCCTG---GGCCGCGATGCTGCCGAGGGGCCGCGGCCG------CTGCTGGTGGTGCGGCCCGGGCCCAGGGGCCTGGCAATACGCCCCGGGCTGGAGGTGGGACCTGAGTCGGGCCTGGCTGGCGCTAAGGCGCTTTTTTTCCTTCGCACCGGG---CCCGAGCCTCCAGGGCCCGACAGCTTCCGCGGCGCAGTGGTCTGCGGGGACCTGCCCGCGGCACCTCTGGAGCACCTAGCCGCGCTGTTCTCGGAGGTTGTTCTACCCGTCCTGGCCAATGAGAAGAATCGCCTAAACTGGCCCCACATGATATGTGAGGATGTCAGGCGGCACGCCCACAGCCTCCAATGTGACCTCTCAGTTATACTTGAGCAAGTGAAGGGAAAAACTTTGCTGCCTCTTCCAGCAGGCTCAGAAAAAATGGAGTTTGCGGATTCCAAAAGTGAGACAGTCTTGGATTCTATAGATAAGTCAGTCATCTATGCCATTGAGTCTGCAGTGATCAAATGGAGCTACCAAGTCCAGGTGGTACTCAAGAGAGAGTCTTCCCAGCCACTCTTACAAGGGGAGAATCCCACCCCTAAGGTGGAGTTGGAGTTCTGGAAGAGCAGGTATGAAGATCTGAAATACATCTATAATCAACTGAGAACAATAACGGTGAGGGGCATGGCCAAGCTCCTGGACAAGCTTCAGAGTAGCTACTTTCCAGCTTTCAAAGCCATGTACAGAGATGTTGTTGCAGCTCTAGCAGAGGCACAGGACATCCATGTGCACCTGATACCGCTCCAGCGCCACCTGGAAGCTCTGGAGAATGCAGAATTTCCGGAGGTGAAGCCCCAGCTGCGGCCCCTGCTCCACGTGGTCTGTCTGATTTGGGCCACATGCAAGTCCTACCGCTCCCCGGGAAGGCTGACTGTGCTGCTCCAGGAGATTTGCAACCTTCTCATCCAGCAGGCCTCTAATTATCTCAGCCCAGAAGACCTGCTGAGAAGTGAGGTAGAAGAAAGTCAGAGAAAACTGCAAGTGGTCTCAGACACTTTGAGCTTCTTCAAGCAAGAGTTTCAGGACAGAAGGGAGAATCTCCACACTTACTTCAAAGAGAACCAGGAAGTCAAGGAATGGGATTTCCAGTCTTCTTTGGTCTTTGTGCGATTGGATGGCTTCCTGGGACAACTGCACGTGGTGGAGGGTCTTCTGAAGACGGCCCTGGATTTCCACAAACTGGGAAAGGTGGAGTTCAGCGGCGTCAGAGGGAATGCTCTGAGTCAGCAGGTCCAGCAAATGCATGAAGAATTTCAAGAGATGTACAGGCTTCTCTCAGGATCCTCCTCCGACTGCCTGTACCTCCAAAGCACGGACTTTGAAAATGACGTCTCTGAATTTAACCAGAAAGTAGAAGATCTTGACCGAAGATTGGGGACTATCTTTATTCAAGCTTTTGATGATGCACCTGGCTTGGAGCATGCCTTTAAGCTGCTAGACATAGCAGGAAACCTCCTTGAAAGACCGCTGGTAGCGAGGGATACATCTGATAAATACCTGGTCCTCATCCAAATGTTCAACAAAGATCTGGATGCAGTGAGGATGATCTACAGTCAGCACGTCCAGGAGGAAGCAGAACTTGGGTTCTCCCCGGTGCACAAGAACATGCCCACCGTGGCTGGCGGCCTCCGCTGGGCACAGGAGCTGAGGCAGCGCATCCAGGGTCCTTTCAGCAACTTTGGACGCATCACACACCCTTGCATGGAATCTGCAGAAGGAAAGCGAATGCAACAAAAATATGAAGATATGCTGTCATTGCTAGAAAAGTATGAGACAAGACTTTATGAGGATTGGTGCCGGACAGTATCAGAGAAGTCACAGTACAATCTTTCCCAACCACTTCTAAAACGTGACCCAGAGACGAAGGAGATCACTATCAACTTTAACCCACAGCTGATTTCAGTGCTGAAAGAAATGAGCTATCTTGAACCCAGAGAGATGAAACACATGCCTGAGACAGCAGCAGCCATGTTCTCCTCCAGGGATTTCTATCGGCAGCTTGTGGCTAATTTAGAGTTGATGGCAAATTGGTACAACAAGGTTATGAAAACTCTGCTGGAGGTGGAATTTCCATTAGTGGAGGAAGAGCTGCAAAATATTGATCTCCGCCTCAGAGCAGCAGAGGAGACTTTGAACTGGAAAACAGAAGGCATTTGCGATTATGTCACTGAAATCACCAGTAGTATTCATGATCTTGAACAAAGAATTCAGAAAACTAAAGACAATGTGGAAGAGATCCAAAACATCATGAAAACATGGGTGACTCCAATATTTAAGACAAAAGATGGAAAAAGGGAATCCCTTCTTTCTCTGGATGATCGGCATGATCGAATGGAAAAATATTACAATCTCATCAAGGAATCTGGCCTTAAGATCCACGCCCTTGTTCAGGAAAACCTGGGTCTATTTTCAGCAGACCCAACCTCCAATATCTGGAAGACTTATGTTAACTCTATTGACAATTTGTTGCTGAATGGATTCTTTCTTGCCATTGAGTGCTCCCTCAAGTATCTTCTGGAAAATACTGAGTGTAAGGCAGGACTTACCCCAATATTTGAAGCACAACTGAGTCTAGCCATCCCAGAGCTAGTTTTCTATCCGTCTCTGGAGTCTGGAGTGAAGGGGGGTTTCTGTGACATTGTTGAGGGTCTCATCACCAGCATTTTTAGGATACCATCTCTGGTGCCACGGCTTTCCCCACAAAATGGCTCTCCTCACTATCAGGTCGACCTGGACGGTATACCAGATTTGGCAAACATGCGGCGCACACTCATGGAGAGAGTCCAGAGAATGATGGGCCTCTGCTGTGGCTATCAGAGCACCTTCAGCCAGTATTCGTACCTCTATGTGGAGGACCGGAAGGAGGTTCTGGGTCAGTTTCTGCTGTACGGGCACATCCTCACTCCGGAAGAAATTGAAGACCATGTGGAAGATGGCATCCCAGAGAACCCTCCCCTCCTTTCTCAGTTTAAAGTGCAAATCGACTCCTATGAAACGCTCTATGAAGAGGTGTGCAGGCTGGAACCCATCAAGGTGTTTGACGGCTGGATGAAAATTGATATTCGACCCTTTAAGGCATCTCTGCTGAATATTATTAAGAGGTGGAGCCTCCTGTTCAAACAGCATCTTGTGGACCACGTCACTCACAGCTTGGCCAACCTGGATGCGTTTATAAAGAAGAGTGAGAGCGGCTTACTCAAGAAAGTTGAAAAAGGAGATTTCCAAGGCTTGGTTGAGATCATGGGACACCTTATGGCTGTTAAAGAACGGCAGAGTAACACTGATGAGATGTTTGAGCCCTTAAAGCAGACTATTGAATTGCTGAAGACCTATGAACAAGAATTGCCAGAAACAGTGTTTAAGCAGCTGGAGGAGCTGCCTGAGAAATGGAACAACATAAAAAAGGTGGCCATTACTGTGAAGCAGCAGGTGGCCCCACTGCAGGCAAATGAAGTGACACTCCTCCGCCAGAGGTGCACAGCCTTCGATGCAGAACAGCAGCAATTCTGGGAGCAATTCCACAAAGAAGCCCCGTTCAGGTTTGATAGCATCCACCCTCATCAAATGCTGGATGCCAGGCACATCGAGATCCAGCAGATGGAATCCACTATGGCCTCCATTTCTGAGTCTGCCAGCTTATTTGAAGTCAATGTCCCTGACTATAAGCAGCTGAGGCAGTGCAGGAAGGAGGTCTGCCAGCTGAAGGAGCTCTGGGACACCATTGGAATGGTGACCTCCAGCATCCATGCCTGGGAGACCACACCCTGGAGGAATATCAACGTGGAAGCCATGGAGTTGGAGTGCAAACAGTTTGCCCGGCATATCCGAAACCTGGACAAGGAGGTCAGGGCCTGGGATGCATTCACAGGCCTGGAAAGCACTGTGTGGAACACGCTGAGCTCCCTGAGGGCAGTAGCTGAGCTGCAGAATCCAGCCATCCGGGAGCGGCACTGGAGGCAGCTGATGCAGGCCACCGGTGTGAGCTTCACTATGGACCAGGACACCACCCTAGCGCACCTGCTGCAGCTCCAGCTGCACCACTATGAGGATGAGGTCCGGGGCATTGTGGACAAAGCTGCAAAAGAGATGGGTATGGAGAAAACCTTAAAGGAGCTGCAGACTACCTGGGCTGGCATGGAATTCCAGTATGAGCCCCACCCACGGACCAATGTCCCCCTCCTGTGCTCTGATGAGGACCTCATAGAGGTTCTGGAGGATAATCAAGTTCAACTTCAGAACCTGGTGATGTCCAAGTATGTTGCTTTCTTCTTGGAGGAGGTGTCGGGCTGGCAGAAGAAGCTGTCCACAGTGGACGCTGTCATCTCTATCTGGTTTGAAGTGCAGCGAACATGGACTCACCTGGAAAGCATATTCACTGGATCTGAAGATATTCGGGCACAGCTACCCCAGGATTCTAAAAGGTTTGAAGGCATCGACATTGACTTTAAAGAGCTAGCTTATGATGCCCAGAAAATTCCAAATGTAGTGCAAACCACCAACAAGCCAGGCCTGTATGAAAAGCTGGAGGATATTCAGGGCAGATTGTGCCTGTGTGAGAAGGCCCTGGCAGAGTACCTCGACACCAAGAGGCTTGCCTTCCCGCGGTTTTACTTTCTCTCCTCCTCCGATCTGTTAGACATCCTTTCCAACGGCACAGCTCCACAACAGGTTCAACGTCACCTTTCCAAACTCTTTGACAACATGGCCAAGATGCGATTCCAGCTAGATGCCAGTGGGGAACCAACCAAGACAAGCCTCGGCATGTACAGCAAAGAAGAGGAGTATGTGGCTTTCAGTGAGCCCTGTGACTGCAGCGGGCAGGTAGAAATATGGCTGAACCATGTCCTTGGTCACATGAAGGCCACTGTGAGGCATGAGATGACAGAAGGTGTAACTGCCTATGAAGAAAAGCCGAGGGAGCAGTGGCTTTTTGACCACCCAGCTCAGGTGGCCCTGACCTGTACTCAGATCTGGTGGACAACAGAAGTGGGCATGGCATTTGCCAGGCTGGAGGAAGGCTATGAGAGTGCCATGAAGGACTATTATAAGAAGCAAGTGGCCCAGCTCAAAACCCTTATCACCATGCTGATTGGCCAGCTCTCCAAGGGAGACCGGCAGAAGATTATGACTATATGCACCATCGATGTGCATGCCCGGGATGTGGTAGCCAAGATGATTGCTCAGAAGGTAGACAATGCCCAGGCTTTCCTCTGGCTGTCTCAGCTGCGCCATCGTTGGGATGACGAGGTCAAACACTGCTTTGCCAACATCTGTGATGCCCAGTTTTTGTATTCCTATGAGTACCTGGGAAACACACCTCGCTTGGTGATCACACCTTTGACT------GACAGGTGCTACATCACCCTCACCCAGTCCCTGCACCTGACCATGAGTGGGGCTCCCGCAGGACCTGCAGGCACAGGCAAGACCGAGACCACCAAGGACCTGGGCCGCGCACTGGGCATCCTGGTCTATGTGTTCAACTGCTCGGAGCAGATGGATTACAAGTCTTGTGGCAACATCTACAAAGGCCTTGCTCAGACTGGTGCCTGGGGCTGCTTTGATGAGTTTAATCGAATCTCCGTGGAGGTCTTGTCAGTGGTGGCAGTGCAGGTAAAAAGCATTCAAGATGCGATTAGAGATAAGAAGCAGTGGTTCAGCTTCCTTGGGGAGGAGATCAGCCTGAATCCTTCTGTCGGTATCTTCATCACCATGAACCCAGGCTATGCTGGCCGCACAGAGCTGCCAGAGAATCTCAAGTCTCTCTTCAGGCCTTGTGCAATGGTGGTTCCAGACTTTGAATTGATCTGTGAAATCATGCTGGTGGCAGAAGGATTCATTGAAGCCCAGTCATTAGCCAGAAAGTTCATCACTCTTTACCAGTTGTGCAAAGAGCTTCTCTCCAAACAGGATCACTACGACTGGGGCCTACGGGCCATCAAGTCCGTGCTGGTGGTGGCAGGATCCCTGAAGAGAGGAGACCCTGACCGGCCTGAGGACCAGGTCCTGATGCGCTCCTTGCGGGATTTCAACATCCCCAAGATTGTGACTGATGACATGCCCATCTTCATGGGCCTGATCGGGGACCTCTTTCCCGCCCTGGATGTCCCCCGGAGGAGAGACCCCAACTTCGAAGCTTTGGTTAGGAAGGCGATAGTGGATCTGAAGCTCCAGGCTGAGGACAACTTTGTGCTCAAGGTGGTCCAGCTGGAGGAGCTCCTGGCTGTGCGGCACTCTGTA---TTTGTGGTGGGTGGCGCTGGT------ACCGGCAAGTCACAGGTGCTGAGGTCCTTGCACAAGACCTATCAG------ATCATGAAACGGCGCCCCGTCTGGACTGACCTCAATCCCAAAGCAGTCACAAATGATGAGCTCTTT---------------------------------------GGCATCATCAATCCAGCCACAGGAGAATGGAAGGATGGA---TTGTTCTCTTCCATCATGCGGGAGCTTGCCAACATCACCCATGATGGGCCCAAGTGGATTTTACTGGATGGCGACATAGATCCAATGTGGATTGAATCCCTGAATACTGTCATGGATGATAACAAGGTGCTGACATTGGCCAGCAATGAGAGGATTCCTCTGAACCCCACCATGAAGCTCCTCTTTGAGATCAGCCACCTGCGCACAGCCACTCCAGCAACTGTCTCTAGAGCAGGGATCTTGTACATCAACCCGGCAGACTTGGGATGGAACCCTCCAGTGAGCAGCTGGATTGAGAAGAGGGAAATCCAGACAGAGAGAGCCAACTTAACCATTTTGTTCGACAAGTATCTTCCAACCTGCCTAGACACACTCAGAACCAGGTTTAAGAAGATCATTCCCATCCCAGAGCAGAGCATGGTTCAGATGGTGTGTCACCTTCTGGAATGTCTCCTGACCACGGAGGACATCCCTGCAGACTGCCCTAAGGAAATTTATGAGCATTATTTTGTGTTTGCTGCCATCTGGGCTTTCGGCGGAGCAATGGTCCAAGATCAGCTTGTGGACTACCGGGCAGAGTTCAGCAAATGGTGGCTGACTGAGTTCAAAACAGTCAAGTTTCCTTCCCAAGGAACCATCTTTGACTATTACATCGACCCAGAGACCAAGAAATTCGAGCCTTGGTCCAAGCTCGTCCCCCAGTTCGAATTTGACCCCGAGATGCCCTTGCAGGCGTGTTTGGTGCACACGAGTGAGACCATCCGTGTGTGCTACTTCATGGAGCGGTTGATGGCGCGGCAGCGGCCTGTCATGCTGGTGGGCACGGCTGGCACTGGCAAGTCGGTGCTGGTGGGAGCTAAGCTGGCCAGCCTTGACCCCGAGGCATACCTGGTGAAAAACGTGCCATTCAACTACTACACCACGTCAGCAATGCTGCAGGCTGTCCTGGAGAAGCCTCTGGAAAAGAAGGCTGGCAGAAACTATGGCCCTCCAGGGAACAAGAAACTCATCTATTTCATTGATGACATGAACATGCCTGAGGTGGATGCCTACGGGACGGTGCAGCCCCACACCATCATCCGGCAGCATCTGGACTATGGCCACTGGTATGATCGGAGCAAGCTGTCCCTAAAGGAGATCACAAATGTACAGTATGTTTCCTGTATGAACCCCACGGCAGGCAGCTTCACCATCAACCCCCGGCTTCAGCGTCACTTCAGCGTGTTTGTCCTCTCCTTCCCGGGGGCAGATGCCCTGTCCTCTATCTACAGCATCATCCTCACTCAGCATCTGAAGCTCGGAAACTTCCCGGCGTCCCTGCAGAAATCCATCCCCCCACTGATCGATCTGGCCCTCGCCTTCCACCAGAAAATTGCTACCACCTTCCTACCCACAGGAATCAAATTCCACTACATCTTCAACCTCAGAGATTTTGCCAACATTTTCCAGGGCATTCTCTTCTCCTCAGTGGAATGTGTGAAATCCACATGGGATCTTATAAGGCTCTATCTGCATGAATCAAATCGAGTTTATCGGGATAAGATGGTAGAAGAAAAGGACTTTGATCTTTTTGATAAAATCCAGACAGAAGTGCTCAAGAAAACTTTTGATGATATTGAAGACCCTGTGGAGCAGACCCAAAGCCCGAACCTGTATTGTCACTTTGCAAATGGTATTGGGGAGCCCAAATACATGCCTGTACAGTCTTGGGAACTTTTGACCCAGACTCTGGTGGAGGCCTTGGAGAACCACAATGAAGTCAACACAGTGATGGACCTAGTTCTCTTTGAGGATGCCATGCGCCATGTCTGCCATATCAATCGCATCTTGGAGTCCCCGCGGGGAAATGCTCTGCTGGTTGGTGTAGGTGGGAGCGGCAAGCAGAGCCTGACAAGGCTGGCAGCTTTCATCAGCTCCATGGATGTCTTCCAGATCACACTGCGCAAAGGCTACCAGATCCAGGACTTCAAGATGGACCTGGCCAGCCTGTGTCTGAAAGCTGGAGTGAAGAATCTCAACACAGTGTTTCTCATGACTGATGCCCAAGTGGCTGATGAGAGGTTCCTTGTGCTCATCAATGATCTTTTGGCATCTGGGGAGATCCCAGATCTCTACTCTGATGATGAAGTTGAAAACATCATAAGCAATGTGAGGAATGAAGTCAAGAGCCAGGGTCTGGTTGACAACAGAGAGAACTGTTGGAAGTTCTTTATAGATCGGATCCGGCGACAGCTGAAGGTGACTCTCTGTTTCTCCCCTGTGGGAAACAAGCTAAGAGTCCGCAGCAGGAAGTTCCCAGCCATTGTGAACTGCACAGCCATCCACTGGTTCCACGAGTGGCCTCAGCAAGCATTGGAGTCTGTCAGCCTCCGCTTCTTGCAGAACACAGAGGGCATTGAGCCCACAGTAAAGCAGTCGATTAGCAAATTCATGGCCTTTGTCCACACAAGTGTCAACCAAACATCCCAGTCTTATCTGAGCAATGAACAGCGCTACAACTATACAACTCCCAAGTCCTTTCTGGAGTTCATCAGACTCTACCAGAGCTTGTTGCACAGGCACAGAAAAGAGCTCAAGTGCAAGACAGAGCGGTTGGAGAACGGGCTGCTGAAGCTGCATAGCACCTCTGCCCAGGTGGATGATCTGAAAGCAAAGCTGGCTGCCCAGGAAGTAGAGCTGAAGCAGAAAAATGAAGATGCAGACAAACTGATTCAGGTCGTGGGTGTGGAGACTGACAAAGTGAGCAGAGAGAAAGCCATGGCAGATGAAGAGGAGCAGAAGGTGGCCGTCATCATGCTAGAGGTGAAACAGAAGCAGAAGGACTGTGAGGAGGACCTGGCAAAGGCTGAGCCAGCACTCACAGCAGCGCAGGCAGCTCTCAACACCCTGAACAAGACCAACCTGACAGAGCTGAAGTCATTTGGCTCTCCGCCTCTGGCCGTCAGCAATGTCAGCGCTGCGGTGATGGTACTGATGGCTCCCAGGGGTAGGGTGCCCAAGGACCGGAGCTGGAAGGCTGCTAAGGTCACCATGGCCAAAGTGGATGGCTTCCTGGACTCGCTAATAAACTTCAACAAAGAGAACATTCACGAGAACTGCCTCAAAGCCATCAGGCCGTATCTGCAAGACCCCGAGTTCAATCCTGAGTTTGTGGCCACCAAATCCTATGCGGCTGCAGGCCTCTGCTCCTGGGTCATCAATATTGTGAGATTTTATGAGGTGTTCTGTGATGTGGAACCCAAGCGCCAGGCACTGAACAAAGCCACCGCGGACCTCACAGCTGCCCAGGAGAAGCTGGCTGCCATCAAAGCCAAGATCGCTCACCTTAATGAAAACCTGGCAAAGCTCACAGCCAGGTTTGAGAAAGCAACAGCAGACAAACTCAAATGTCAGCAAGAAGCCGAAGTGACCGCAGTCACCATCTCCCTTGCCAACCGCCTGGTTGGAGGACTCGCTTCTGAAAACGTGAGGTGGGCAGATGCCGTGCAGAACTTCAAACAGCAGGAAAGGACGTTATGTGGAGACATTTTACTTATAACGGCTTTCATTTCCTACCTTGGCTTCTTCACAAAGAAATACCGGCAGAGCCTCCTGGACAGAACTTGGAGGCCCTACCTGAGCCAGCTGAAAACTCCCATTCCAGTCACCCCAGCCCTGGATCCCCTGAGGATGCTGATGGATGATGCTGACGTGGCTGCCTGGCAGAACGAGGGCCTCCCAGCCGACCGCATGTCCGTGGAGAATGCCACCATTCTCATCAACTGTGAGCGCTGGCCACTCATGGTTGACCCTCAGCTACAAGGCATCAAATGGATCAAGAATAAATATGGTGAAGATCTCCGGGTCACGCAGATTGGTCAGAAAGGCTACCTTCAAATCATAGAGCAGGCCCTGGAAGCTGGAGCTGTGGTGCTGATTGAAAATCTAGAGGAGTCCATTGATCCTGTTCTGGGACCCCTGCTTGGGAGAGAAGTCATTAAAAAAGGACGATTCATTAAAATTGGAGACAAAGAATGTGAATACAATCCCAAGTTCCGGCTCATCCTCCACACCAAGCTGGCTAATCCTCACTACCAGCCTGAGCTGCAGGCTCAGGCCACCCTGATCAACTTCACCGTGACCAGGGATGGCCTGGAGGACCAGTTGCTGGCCGCTGTGGTCAGCATGGAGAGGCCAGACTTGGAGCAGCTGAAGTCCGATCTCACAAAGCAGCAGAATGGATTCAAAATTACCCTGAAAACGTTGGAAGACAGTCTTCTCTCTCGCCTCTCCTCCGCCTCTGGGAACTTCCTGGGAGAAACAGTGCTGGTGGAAAACCTAGAGATCACCAAGCAGACTGCTGCCGAAGTTGAGAAAAAGGTCCAGGAGGCCAAGGTGACTGAAGTGAAAATCAACGAGGCCCGAGAGCACTACCGGCCAGCAGCTGCCAGGGCCTCACTGCTCTACTTCATCATGAACGACCTCAGCAAGATCCATCCAATGTACCAGTTTTCTCTCAAGGCCTTCAGTATCGTCTTCCAGAAGGCTGTGGAG------AGGGCTGCTCCTGACGAAAGCCTCAGGGAGCGGGTGGCCAACCTAATAGACAGCATAACCTTCTCTGTGTACCAGTACACCATCCGCGGGCTCTTTGAGTGTGATAAGCTGACCTACCTTGCCCAGCTCACCTTTCAGATTCTCCTCATGAACCGAGAAGTCAATGCAGTGGAGTTGGATTTCCTGCTTCGATCTCCAGTGCAGACGGGCACCGCCAGCCCCGTGGAGTTCCTCTCCCATCAGGCGTGGGGAGCTGTCAAGGTACTTTCATCAATGGAAGAATTCTCTAATCTGGATCGGGACATAGAGGGATCTGCTAAGAGCTGGAAAAAGTTTGTGGAGTCCGAATGTCCTGAGAAAGAGAAGCTCCCACAGGAGTGGAAGAACAAGACAGCCCTGCAGCGCCTCTGCATGCTGAGAGCCATGCGGCCCGACCGGATGACCTATGCTTTGCGAGATTTTGTTGAAGAGAAGTTAGGAAGCAAATACGTGGTGGGAAGAGCCCTAGATTTTGCAACCTCATTTGAAGAATCGGGACCAGCCACTCCTATGTTTTTCATCCTGTCTCCAGGGGTGGACCCACTGAAGGATGTAGAAAGTCAAGGAAGAAAACTTGGATACACCTTCAACAATCAGAACTTTCACAACGTGTCTTTGGGGCAAGGACAGGAAGTGGTGGCTGAGGCTGCGCTGGACCTCGCTGCCAAGAAAGGTCACTGGGTTATTTTGCAGAACATTCACCTGGTGGCCAAGTGGCTCAGCACCCTGGAGAAGAAGCTGGAGGAGCACAGTGAGAACAGCCACCCAGAGTTCAGGGTCTTCATGAGTGCAGAGCCAGCACCCTCCCCTGAGGGCCACATCATCCCCCAGGGCATCCTGGAGAACTCCATTAAGATCACCAATGAGCCCCCCACGGGCATGCATGCCAACCTGCACAAGGCCCTGGACAACTTCACTCAGGACACTCTGGAGATGTGTTCTCGGGAGACGGAGTTTAAGAGCATCCTCTTTGCTCTTTGTTACTTCCATGCGGTGGTGGCAGAAAGACGAAAATTTGGGCCCCAGGGATGGAATCGCTCATACCCCTTTAACACTGGAGACCTCACTATCTCTGTGAATGTCCTCTACAACTTCCTGGAGGCCAACGCAAAGGTCCCCTATGATGATTTGCGCTACCTGTTTGGAGAGATCATGTATGGAGGCCATATCACAGATGACTGGGACAGAAGACTCTGCAGAACCTACCTGGGGGAATTCATTCGACCAGAAATGTTAGAAGGAGAACTGTCTTTGGCCCCAGGGTTCCCACTCCCAGGCAACATGGACTACAATGGTTATCATCAGTACATCGATGCTGAGCTGCCCCCAGAATCCCCCTACCTCTATGGCCTCCACCCGAACGCAGAGATTGGCTTCCTGACCCAAACCTCAGAAAAGCTCTTCCGCACTGTGCTGGAGCTGCAGCCTCGGGACAGCCAGGCCAGAGACGGAGCGGGCGCCACAAGAGAAGAAAAGGTCAAGGCACTTCTGGAAGAAATATTGGAGCGGGTGACAGACGAGTTTAACATCCCAGAACTGATGGCCAAAGTGGAGGAGCGCACCCCTTACATTGTAGTTGCCTTCCAGGAGTGTGGCCGGATGAATATCCTCACCAGAGAGATTCAGCGCTCACTGAGGGAGCTGGAGCTCGGCTTAAAGGGGGAGCTGACTATGACCAGCCACATGGAGAACTTACAGAATGCCCTGTACTTCGATATGGTGCCAGAGTCCTGGGCTAGACGAGCCTACCCTTCCACAGCAGGCCTGGCAGCCTGGTTTCCAGACCTCCTCAACAGAATCAAGGAGCTAGAGGCTTGGACGGGTGACTTTACAATGCCCTCCACTGTGTGGCTGACAGGCTTCTTCAACCCCCAGTCGTTCCTGACTGCCATCATGCAGTCCACGGCTCGCAAGAATGAGTGGCCACTGGACCAGATGGCCCTGCAATGTGACATGACGAAGAAGAACAGAGAAGAGTTTAGGAGTCCTCCTCGGGAAGGGGCCTACATCCATGGCCTCTTCATGGAAGGTGCCTGCTGGGACACACAGGCTGGGATCATTACAGAGGCAAAGCTGAAGGATCTGACACCCCCTATGCCTGTGATGTTCATCAAGGCCATTCCTGCAGATAAGCAGGACTGCCGCAGTGTCTATTCCTGTCCTGTGTACAAGACTAGTCAGCGGGGACCCACCTACGTGTGGACTTTCAACCTGAAGACTAAGGAAAACCCATCCAAGTGGGTTCTGGCTGGAGTAGCCTTGCTTCTCCAGATT
->Mouse
-ATGCCCGGCGCCAAGGAGCAGGCAGCGCTG---------GCGGAGTCTGGGGACGAGGAGCCTGGA------GACCCGAGGCTGCGGCTTCTGGGGACTTTTGTGGCTCGGAGCCTGCGTCCGGCCGCGGGCACCTGGGAGCGCTGTGCAGGCACAGCCGAGGCGGGGAGGCTGCTGCAGGCCTTCCTG---GATCACAACGCTGCCTCGGATCCGCGGCCA------CTGCTGGTGGTTCAGTCCGGGCCCGGGGGCCTGGTGGTGACACCCGGTCTAGACGCAGGACCAGAGCCCAGCCGAGCTCGCGCCAAGGGGCTCTTTTTCTTGCGCACTAAG---TCCGAGCCTCCGGGAAATCACAGCCTCCGCGGCACGGTGCTCTGCGGGGACCTACCCGCGGTGCCACTGGAGCACCTGGCCCCGCTGCTCTCAGAGGTCATTATTCCTGTCCTGGCAAATGAAAAGAACCATTTAGAATGGCCCCACATGGTATGTCAAGACATCAGACATCATGCCCACACCCTGAAGTCTGACCTCCTAGTGATCTTTGAGCACATGAAGGGGAGAACCTTGCTGCCTCTTCCAGTTGGCTCAGAAAAACTGGAGTTTGTGGATGGCCACAGTGAGCCAGTCTCAGATGCCATAGACAAGTCAACTCTCTATGCTGTGGAGTCTGCAGTGATCAAATGGAGCCACCAAGTCCAGGTGGTACTCAAGAGGGAGTCTTCTCAGGCACTCATACAAGGACAAAATCCCACCCCCAAGGTGGAGCTGGAGTTCTGGAAGAGCAGGTGTGAGGACCTGGAACACATTTATAATCAACTAATGACAATCAAGGTGAAGGGAATGGCTGAACTCCTGGACAAACTTCAGAGCAGCTACTTGCCAGCTTTCAAAGCCATGTTCAGAGACGTTGAAGCAGCCCTGACCGAGGCCCAGGACATCCATGTGCACCTGTTACCTCTCCAGCAACACCTGGACATCCTGGAAAACGTGGAGTTTCCCAAGGTGAAGGGCAGGCTGCGGCCTCTGCTCCATGTGGTCTGTCTGATTTGGGCCACCTGCAAATGGTACCGTTCCCCTGGGAGGCTCACAGTGCTGCTCCAAGAAATCTGCAACCTCCTCATCCAGCAGGCCTCTAATTACCTCAGCCCAGAAGACCTCCTGAGAAGTGAGGTGGAAGAGAGTCAGAAAAAACTGCAAGTGGTCTCAGATACCTTAAGCTTCTTCAAACAGGCATTCCAGGACAGAAGGGAGCACCTCCACACTTACTTCAAGGAGGATTCTGAAGTCAGGGTGTGGGATTTCCAAGCATCTCTGGTGTTTGTGCGACTGGATGGCTTTCTGGGCCGAGTGCACATGGTGGAGGATCTTCTGAAGACAGCCTTGGATCTCAACAATCTGGAAAAGCTTGAGTTCAGTGGCCTCAGAGGAAACTCCCTGAGTCAGAAAGTCCAACGCATGCATGAGGAATTTGAGGAGATGTACAAGGTCTTCTTGGACTGCTCCTATGACTGTTTGGACCCCAAGGGCACGGAATTTGAAAATGATGTCTGTGAGTTTAACAAAAGAGTGGAAGATCTTGACCGGAGACTGGGGACTATCTTAATTCAAGCTTTTGATGATGCACCTGATGTGGAACATGCCTTTAAGCTACTGGACATCACAGGAACCCTCATCAAAAGACCCCTGGTAGCACAGGATGTATCACAAAAATACCTGGCCCTCATCCGAATGTTCAGCACAGAACTGGATGCTGTGAGGGTCATCTACAGTCAGCACATCCAGAAGGAGGCAGAGCATGGATTCTCCCCCGTGCACAAGAACATGCCCACTATGGCTGGCGGCATCTGCTGGGCACAGGAACTGAGGCAGCGCGTCAAGGGTCCCTTTGGCAACTTCAAAAACATACCACATCTGTACTTGCAATCTGCTGAAGGAAAGCGAATGATACAAAAATACGAAGACTTGCTCTCCCTGCTAGAAGAGTATGAGAGAAGACTTTATGAGGACTGGTGTCAGACGGTATCTGAAAAGTCACAGTACAATCTTTCCCTACCTCTTTTGCATCGTGACCCCAACACAAAGCAGCTCTCTGTCAACTTTAACCCACAGCTGATTTCAGTGTTGAAAGAAATGAACTATCTTCAGCCCAGTGAGGTGAAAACCATCCCCGAGACCGCAGCAGCCATGTTCTCCTCCAGGGAATTCTATCGTCAGCTTGTGGCCAACTTGGAGTTGATGGCAAATTGGTACAACAAGGTTATAAAAATTCTGCTGGAGGTGGAATTTCCACTAGTGGAGGAAGAACTGCAAAATATTGATCTCCGCCTGAGAGCTGCAGAGGAGACTCTGAGCTGGAAAACAGAAGGCATTTGGGATTATGCTATGCAAATAACCAATAGCATTCATGACCTGGAACAAAGAATTCAGAAGACAAAAGACAATGTGGAAGAGATTCAAAACATCATGAAAACATGGGTGTCTCCAATATTCAAGAGAAAAGATGGGAAAAAAGAATGGCCCCTTTCTCTGGATGATCAGCAGGATCACATGGAAAAATACTACAGTCTCATCCAGGAATCTGGCCTTAAGATTCACGCTCTTGTTCAGGAAAACCTGGTTCTGTTTGCAGCAGACCCAGCATCCAGCATTTGGAAGTCTTACGTGAACTACATTGATTCCATGTTGTTGGATGGATTTTTTCTTGCCATTGAGTGTTCTCTCAAATATCTATTGGAAAACACTGAATGCAAGCCTGGACTCACCCCAGTATTTGAAGCACAGCTCAACCTTGTCACCCCAGAATTAGTTTTCCACCCCTCTCTGGACTCTGGGGTAAAGGGAGGCTTATATGACATTGTCCAGAGTCTTGTCACCAGAATTTTTGCTATGCCATCCCTCGTGCCACGGCTTTCCCCACACAGTGGCTCTCCTCACTATCAGGGTGACCTAGAGGACATGGCCGACTTAGCTGGTCTTCGGAGTGTGCTCATGGAGAGGGTACAGAATATGATGACCCTCTGCTGTGGCTATAGAAATACCCTCAGCCAGTATTCTTACCTGTATGTGGAGGATAGGAAGGAGATTCTTGGTCAGTTTCTGCTCTATGGGCATGTCCTCACACCTGAAGAGATAGAAGCCCATGCCGAAGACGGCATTCCAGAAAATCCACCCCTCCTCCATCACTTCAAAGACCAGATAGACTCCTATGAAAAGCTCTATGAGGAGGTGGTCAGCCTGGAACCCACCAAGGTGTTTGATGGCTGGATGCGAGTGGATGTGAGACCCTTCAAAGCATCTCTGCTGAACACAATAAAGAAGTGGAGCCTCATGTTCAAGCAACATCTTGTTGACTTTGTCACAAACAGCCTGTCTGACCTTGACTCATTCATAAGGAGCACCGAGAGTGGTTTGCTCAAGAGGGTGGAGAAAGGAGATTTCCAAGGATTGGTTGAGATCATGGGACATCTTGTCACCCTTAAAGAACGGCAGAGCAGCACCGATGACATGTTTGAGCCCCTGAAGCAAACGATTGAACTGCTGAAGTCCTACGAACAAGAGCTGCCAGAAACCGTGTTTAAGCAACTGGAGGAGCTTCCTGAGAAGTGGAAGAACATGAAGAAGATGGCCATCACTGTGAGGCAACAGGTGGCCCCTCTGCAGGCAAATGAAGTGGCCCTACTCCGCCAGCGGTGCTCAGCCTTCGATGATGAGCAGCAGCAATTCCAGGAGAGGTTCCGCAAAGAGGCCCCTTTCAGGTTTGATAGTATCAATCCACACCAAATGCTGGATGCCTGGCACGTGGAGATCCAGCACATGGAATCCACCATGGCAACCATCTCTAAGTCGGCTGATTTGTTTGAAGTCAATGTTCCTGACTACAAGCAGCTGAGGCAGTGCAGGAAGGAGGCCTGCCAGTTAAAGGAGCTCTGGGACACCATTGGAATGGTGACCTCCAGCATCCGTGCCTGGGAGGCCACCAGCTGGAGGAATATCAGTGTGGAAGCCATGGACTCAGAGTGCAAGCAGTTCGCCCGGCACATCCGCAACCTAGATAAGGAGTTCAGGTCCTGGGATGCATTCACGGGCCTGGAAAGCACAGTGTTGAACACCCTGACGTCCCTGAGGGCTGTGGCGGAGCTGCAGAATCCTGCCATCCGGGATCGGCACTGGAGGCAGCTGATGCAGGCCACCGGGGTGAATTTCACCATGAATCAGGATACCACCTTAGCTCATCTCCTGCAGCTTCAGCTCCACCACTTCGAGGATGAGGTCCGAGGCATTGTGGACAGAGCTGTCAAAGAGATGAGTATGGAGAAGACCTTAAAGGAATTGCAGACTACCTGGGCCAGCATGGAATTCCAGTACGAGTCCCACGCAAGAACCCGCGTACCCTTGCTGCAGTCAGATGAGGATCTCATTGAGGTCCTAGAGGACAATCAAGTGCAACTTCAGAACCTGATGATGTCCAAATATGTTGCTTTCTTCCTGGAAGAAGTGTCGAGCTGGCAGAAGAAGCTGTCCACGGCTGACTCGGTCATCTCTATCTGGTTTGAGGTGCAGCGCACCTGGTCTCACCTAGAGAGCATATTCATTGGCTCAGAAGATATCCGGGCTCAGCTACCCCAGGACTCTAAGAGATTTGAAGGCATTGACTCTGACTTCAGAGAGCTGGCGTATGATGCTCAGAAAACCCCAAATGTGGTGGAAGCCACAAATAAGTCAGGTCTCTATGAAAAGCTGGAGGATATACAAAGCAGATTATGCCTGTGTGAGAAAGCCCTAGCAGAGTATCTAGACACCAAGAGGCTCAGCTTCCCTCGCTTTTACTTCCTGTCCTCCTCTGACCTGCTGGACATCCTTTCCAATGGCACAGCTCCACAACAGGTTCAACGGCACCTCTCCAAGCTCTTTGACAACATGGCTAAGATGCAGTTCCAGTTAGATGCCAGTCAGAACCCAACCAAGACGAGCCTTGGCATGTACAGCAAAGAGGAGGAATATGTGGCCTTCAGTGAGGCCTGTGACTGCAGTGGGCAGGTTGAAATATGGCTGAACCGTGTTCTTCGTCACATGAAAGCCACTGTGAGGCATGAGATGACAGAGGGGGTCACTGCCTATGAGGAAAAGCCCAGGGATCAGTGGCTGTTTGATTACCCGGCTCAGGTGGCTCTGACCTGCACTCAGATCTGGTGGACGACAGAGGTGGGCATTGCATTTGCCAGGCTGGAGGAAGGCTATGAGAGTGCCATGAAGGACTACTATAAGAAGCAAGTGGCCCAACTCAAAACCCTTATCACCATGCTAATTGGGCCGCTCTCCAAGGGGGACAGGCAAAAGATCATGACCATATGCACCATCGATGTGCATGCCCGGGATGTGGTAGCCAAGATGATTGCTCAAAAGGTTGACAATGCCCAGGCTTTCCTCTGGCTGTCACAGCTACGACATCGTTGGGATGATGAGGCCAAGCACTGCTTTGCTAACATCTGTGACGCCCAGTTTCTATATTCCTATGAGTACTTGGGAAATACACCTCGCCTAGTGATCACGCCTCTGACT------GATAGGTGCTACATCACTCTCACCCAGTCTCTACACTTGACCATGAGTGGGGCTCCAGCAGGACCTGCAGGCACAGGCAAGACAGAGACCACCAAGGACCTGGGCAGAGCACTCGGCATCATGGTCTATGTGTTTAACTGTTCTGAGCAGATGGACTACAAGTCCTGTGGCAACATCTACAAAGGCCTGGCTCAGACTGGTGCCTGGGGCTGTTTTGATGAGTTTAACCGAATCTCTGTGGAGGTCTTGTCGGTGGTGGCTGTCCAGGTAAAAAGCATCCAGGATGCAATCAGAGACAAGAAGCAGAGGTTCAGCTTCCTTGGAGAGGAGATTAGCCTTGACCCTTCAGTGGGCATCTTCATTACCATGAACCCAGGCTATGCTGGCCGCACAGAACTGCCAGAGAACCTCAAGGCCCTTTTCAGGCCCTGTGCAATGGTAGTTCCAGACTTTGAGCTGATCTCTGAGATTATGCTGGTAGCAGAAGGATTCATTGAAGCCCGGTTGTTGGCCAGGAAGTTCATTACCCTTTACCGGCTGTGTAAAGAACTTCTCTCCAAACAGGATCACTATGACTGGGGACTTCGTGCCATTAAGTCTGTCCTCGTGGTAGCAGGATCACTGAAACGGGGAGACCCTGACCGCCCAGAGGACCAAGTCCTGATGCGTTCTTTGAGAGACTTCAACATCCCAAAGATCGTGACAGATGACATGCCGGTGTTCATGGGTCTGATAGGTGACCTCTTTCCTGCTTTGGATGTCCCCAGGAAGAGAGATCTGGACTTTGAGGCTGTGGTTCGGAAAGCAATCGTGGACCTTAAGCTCCAGGCTGAGGACAACTTTGTGCTCAAGGTGGTCCAGCTGGAGGAGCTGCTAGCTGTAAGGCACTCTGTG---TTCGTGGTGGGCGGTGCTGGT------ACCGGGAAGTCACAGGTACTGAGGTCTTTACACAAGACCTATCAG------ATCATGAGACGTCGCCCTGTGTGGACTGACCTCAACCCCAAAGCTGTCACAAATGATGAACTCTTT---------------------------------------GGCATCATCAATCCAGCCACTCGAGAATGGAAGGATGGA---CTGTTCTCTTCCATCATGAGAGAGCTTGCCATCATCTCTCATGATGGGCCCAAGTGGATCTTACTGGATGGCGATATAGACCCGATGTGGATAGAGTCTCTGAACACAGTCATGGATGATAACAAGGTACTGACCCTGGCAAGCAACGAGAGAATCCCCCTTAACCCCACAATGCGTCTTCTTTTCGAGATCAGCCACCTGCGCACAGCCACACCAGCAACCGTCTCCAGAGCAGGGATCCTGTACATAAACCCTGCAGACCTGGGATGGAACCCTCCAGTAAGCAGCTGGATTGATCAGAGAGAAGTCCAGACTGAGAGAGCCAACTTGACCATCCTGTTTGACAAATATCTTCCTACCTGCTTGGACACCCTCAGAACCAGATTTAAGAAAATAATTCCAGTCCCAGAGCAGAGTATGATCCAGATGCTGTGCTACCTCCTTGAGTGCCTCCTGACAAAGGAGGATATCCCTGCAGACTGCCCCAAGGAAATATATGAACTCTATTTTGTGTTTGCTGCCATCTGGGCATTTGGCAGTGCTGTGATCCAAGATCAGCTTGTAGACTACCGGGCAGAGTTCAGCAAATGGTGGCTGACTGAGTTTAAAACAGTCAAGTTTCCTTCCCAAGGAACTGTCTTTGACTACTACATAGACCCAGAGACCAAGAAATTTGAGCCCTGGGCCAAGCTCATCCCCCAGTTTGAATTTGACCCAGAGATGCCTTTGCAGGCTTGTTTGGTACACACAAGTGAGACCATCCGGGTGTGCTACTTCATGGAGCGGCTCATGCAATGGAGGCGGCCGGTTATGCTGGTTGGCCCTGCAGGCTCAGGCAAGTCTGTGCTGGTGGGAGCAAAGCTGTCCAGCCTTAACCCTGAGGAATACATGGTGAAAAATGTGCCCTTCAACTACTATACTACGTCAGCAATGCTGCAAGCTGTCTTGGAGAAACCTCTAGAAAAGAAAGCTGGCAGGAATTATGGCCCTCCAGGCAACAGGAAACTCATCTATTTCATCGATGACATGAATATGCCCGAGGTGGATGCCTATGGCACAGTACAGCCCCACACTGTCATCAGGCAGCACCTAGACTATGGCCACTGGTATGATCGGAACAAGCTGTCTCTGAAGGAGATCATGAATGTACAATACATCTCCTGTATGAACCCCACTGCAGGCAGCTTTACCATCAACCCAAGGCTTCAGCGCCACTTCAGCGTGTTTGCCCTCTGCTTCCCAGGAGCTGATGCCCTCTCTTCCATCTATAGCACCATCTTGACCCATCATCTGAAGTTTGGAAACTTTCCCACCACCCTGCAGAAATCCATCCCTCCTCTGATAAACCTGGCTGTCACCTTCCATCAGAAAATTGCCACCACGTTTCTGCCCACAGCAATCAAATTTCACTACATCTTCAATCTCAGAGATTTTGCCAATATTTTCCAAGGCATTCTTTTCTCCTCCGTGGAATGTGTAAAGTCCACACAGGACCTAGTGAAACTCTATCTGCACGAGTCAAGTCGGGTTTATCGGGATAAGATGGTGGAAGAAAAGGATTTCAATCTTTTTGACAAAATCCAAACAGAATTCCTCAAGAAAAATTTTGATGATAGTGAAGAGGTGCTGAAGCAGACCCAGAACCTGAACATGTATTGTCACTTTGCAAATGGCATTGGTGAGCCCAAGTACATGCCTGTGCAATCATGGGACCTTCTGAATCAGACTCTGGTGGAAGCCCTGGAGAGCCACAATGAAGTGAATGCTGTGATGGACCTAGTTCTCTTTGAGGATGCCATACGTCACATCTGTCACATCAACCGAATCCTGGAGTCCCCTCGAGGAAATGCCCTGCTAGTTGGTGTAGGTGGGAGTGGTAAGCAGAGTCTGACAAAGCTGGCAGCTTTTATCAGTTCCATGGATGTATTCCAGATCACCCTTCGCAAAGGCTACCAAATCCCTGACTTCAAGGTGGACCTGGCCAGCCTCTGTCTGAAAGCTGGGGTAAAAAATCTCAGTACAGTGTTCCTTATGACTGATGCCCATGTGGCTGACGAGAGGTTCCTGGTGCTCATCAATGACCTCCTGGCATCTGGTGAGATCCCAGATCTCTACTCTGATGAGGAAGAGGAGAACATCATAAACAATGTGAGAAATGAGGTCAAAAGCCAGGGACTCATGGACAGCAGGGAGAACTGCTGGAAATTCTTCATAGAGAGAGTCCAGCGACAACTTAAGGTGACTCTCTGTTTCTCCCCTGTGGGGAACAAGCTGAGAATTCGAAGCAGGAAGTTCCCAGCCATTGTGAACTGTACTGCTATCAACTGGTTCCATGAGTGGCCTCAGGAGGCCCTAGAGTCTGTGAGCCTCCGATTCTTGCAGAATACAAAGAACATTGAGCCTGCGGTGAAGCAGTCAATTAGCAAGTTCATGGCCTTTGTCCACATAAGTGTCAACAAGACATCCCAGTCATACCTGACCAATGAGCAGCGATACAACTACACAACACCCAAGTCCTTTCTGGAGTTCATCAGACTGTACCAGAGCTTGCTGGAGAGAAATGGAAAAGAGCTCCAGGCCAAGGTGGAGAGGCTGGAGAACGGGCTGTTGAAACTGCACAGCACCTCGGCCCAGGTGGATGATCTGAAAGCGAAGCTTGCCACCCAGGAAGTGGAGCTGAGGCACAAGAATGAAGATACAGACAAGCTGATTCAGGTGGTGGGTGTGGAGACCAGCAAAGTGAGCAGAGAGAAAGCCATTGCTGACGAGGAGGAGCAGAAGGTGGCCCTGATCATGCTGGAGGTGCAGCAGAAACAGAAAGACTGTGAAGAGGACCTGGCTAAGGCCGAGCCAGCCCTGACCGCAGCGCAGGCGGCCCTCAACACTCTCAACAAGACCAACCTGACAGAGCTGAAGTCATTTGGTTCCCCACCTCTGGCTGTCAGCAATGTCAGCGCCGCGGTGATGGTTCTCATGGCCCCAGGGGGCAAGGTGCCCAAGGACCGCAGCTGGAAGGCTGCCAAAATCACCATGGCCAAGGTGGACAGCTTCCTGGATTCCCTAATCCACTTCGACAAGGAGAACATTCATGAGAATTGCCTCAAAGCCATCAGGCCATACCTGCAAGATCCTGCATTCAACCCAGAGTTTGTGGCCACCAAGTCCTATGCAGCTGCAGGCCTCTGCTCTTGGGTAATCAATATTGTGAGGTTCTATGAGGTCTTCTGTGATGTGGAACCAAAGCGCCAGGCTTTGAACAAAGCCACCTCAGACCTCACAACTGCCCAAGAGAAGCTGGCAGCCATCAAAGCCAAGATCACACACCTTAATGAAAACCTGGCGAAGCTCACCACCAAGTTTGAGAAAGCAACAGCAGAGAAGCTCAAGTGTCAGCAAGAAGCTGAACTGACCGCAGGCACCATTTCGCTTGCAAACCGTCTGGTTGGAGGCCTTGCATCTGAGAACATAAGGTGGGCAGAGGCTGTGCAGAACTTCAGACAGCAGGAAAGGACGTTATGTGGCGACATTCTGCTTACTACAGCTTTCATCTCCTACTTGGGCTTCTTTACCAAAAAGTACCGAAAGAGCCTCATGGATGGGACCTGGAGACCCTATCTGAGCCAACTGAAAGTTCCCATTCCAACCACCCCAACTCTGGACCCCCTGAGGATGCTAACCGATGATGCTGAAGTGGCTGCCTGGCAGAATGAGGGTCTCCCTGCTGACCGCATGTCCATGGAGAATGCTACCATCCTCATCAACTGTGAGCGCTGGCCTCTCATGGTCGACCCTCAACTGCAAGGCATTAAATGGATCAAGAACAAATATGGAGAAGAACTCCGGGTCACCCAGATTGGCCAAAAGGGCTGCCTTCAAACCATAGAGCGAGCCCTGGAAGCTGGAGATGTGGTACTGATTGAGAACCTTGAGGAGTCCATTGATCCCGTCCTGGGACCTCTGCTTGGGAGAGAAGTCATTAAGAAAGGACGGTTTATCAAGATTGGAGACAAGGAGTGTGAATTCAATCCCAAGTTCCGGCTCATCCTTCATACCAAGCTGGCCAACCCTCACTACCAGCCTGAGCTGCAGGCTCAGGCTACCCTGATCAACTTCACGGTGACCAGGGATGGCCTGGAGGACCAGCTGCTGGCTGCTGTGGTCAGCATGGAGAGACCAGACCTGGAACAGCTGAAGTCCGATCTCACAAAGCAGCAGAACGGGTTCAAAATCACCCTCAAAACCTTAGAGGACAACCTGCTATCTCGCCTCTCTTCAGCCTCGGGGAACTTCCTGGGAGAAACAGCCTTGGTGGAGAACCTGGAGGTCACCAAGCAGACTGCTGCAGATGTGGAGGAAAAGGTCCAAGAAGCCAAATTGACAGAAGTAAAAATTAATGAGGCCCGAGAGCACTATAGGCCAGCAGCTGCCCGGGCATCTCTGCTCTACTTCATCATGAATGACCTCAGCAAGATCCATCCAATGTATCAGTTCTCCCTCAAGGCCTTCAGCATTGTCTTCCAGAAAGCTGTGGAG------AAGGCAGCTCCCAGTGAAAGTGTCACAGAGCGAGTGACTAATCTAATAGACAGCATAACTTTCTCAGTGTACCAGTATACCACACGTGGCCTCTTTGAGTGTGATAAGCTGACCTACCTAGCCCAGCTCACCTTTCAGATTCTCCTCGTGAACCAGGAAGTTAATGCAGCAGAGTTGGATTTCTTGCTTAGGGCTCCAGTACAGACAGGGACTCCCAGCCCAATGGAGTTCCTGTCCCACCAGGCCTGGGGAGGCATCAAGGCACTCTCATCAATGGAGGAATTCTGCAATCTGGACCGAGACATTGAAGGCTCTGCCAAGAGCTGGAAAAAGTTTGTGGAGTCAGAGTGTCCCGAGAAGGAGAAGTTTCCCCAGGAGTGGAAGAACAAGACAGCCCTGCAGCGCCTCTGCATGATGAGAGCCATGAGGCCTGACCGGATGACCTATGCCATGCGAGATTTTGTTGAGGAGAAGTTGGGAAGCAAATACGTGATGGGAAGAGCACTCGATTTTGTAACCTCATTTGAAGAGTCAGGACCAGCCACTCCCATGTTTTTCATCCTGTCTCCAGGGGTGGATCCACTGAAGGATGTGGAAAATCAAGGAAAGAAACTTGGATATACATTCAACAATCGGAACTTCCACAACGTGTCCCTAGGGCAAGGACAAGAGGTAGTTGCTGAGGCTGCACTGGACTTGGCTGCTAAGAAGGGTCACTGGGTGATTCTGCAGAACATCCACCTGGTGGCCAAGTGGCTCAGTACCCTGGAGAAGAAACTGGAGGAGCTCAGCGAGGAAAGTCACCCAGACTTCAGGGTCTTCATCAGCGCAGAGCCTGCACCCTCCCCTGAGGGCCACATCATTCCCCAGGGCATTCTGGAAAACTCCATTAAGATCACCAATGAGCCTCCCACAGGCATGCACGCCAACTTACACAAAGCCCTGGACAACTTCACTCAGGACACTCTGGAGATGTGTTCCCGGGAGACAGAGTTCAAGACCATCCTCTTTGCTTTGTGCTACTTTCATGCGGTGGTTGCCGAGAGACGGAAGTTTGGGCCACAGGGCTGGAATCGGTCCTATCCATTTAACACTGGGGACCTCACCATCTCTGTGAATGTGCTATATAATTTCCTGGAGGCTAACACAAAGGTACCCTATGACGACTTGCGTTACCTGTTCGGTGAGATCATGTACGGTGGCCATATCACAGATGACTGGGACAGGAGACTCTGCAGAACCTATTTAGAGGAATTCATTCGGCCAGAGATGCTAGAAGGAGAGCTCTCCCTGGCCCCGGGGTTCCCACTCCCAGGAAACATGGACTACAGTGGCTATCACCAGTATATTGATGCTGAGCTGCCCCCTGAGTCTCCCTACCTATATGGCCTCCATCCAAACGCCGAGATTGGCTTCCTGACCCAGACATCGGAAAAACTCTTCCGAACCGTGCTGGAGATGCAGCCTCGGGACAGCCAGGCTGGAGATGGAGCTGGCATCACAAGGGAAGAAAAGGTCAAAACCTTTCTGGAAGAAATACTGGATCGGATGACAGATGAATTTAACATCGCGGAGCTAATGGCTAAGGTGGAGGAACGCACCCCCTACATTGTAGTTGCCCTCCAGGAGTGTGAACGCATGAACATCCTTACCAGAGAGATCCAGCGCTCACTAAGAGAGCTGCATCTTGGCTTACAGGGGGAGCTGACCATGACCAGTGAGATGGAAAACCTACAGAATGCCCTATATCTAGATGTGGTCCCAGAGTCCTGGGCCAGGCGAGCCTACCCTTCCACAGCAGGCCTGGCAGCCTGGTTTCTAGACCTGCTTAACAGAATCAAAGAGCTGGAGTCCTGGACAGGCGACTTCTTGATGCCCTCAACTGTGTGGCTGACGGGCTTCTTCAACCCCCAGTCCTTCCTGACTGCCATCATGCAGTCCATGGCCCGCAAGAATGAATGGCCACTAGACCAGATGGCCCTGCAGTGTGATGTGACAAAGAAGAACAGAGAGGAGTTCCGGAGCCCTCCTCGGGAAGGGGCCTACATCTATGGGCTCTTCATGGAAGGTGCCTGCTGGGACACACAGACTGGGATCATTGCAGAGGCGAAACTGAAGGACCTGACACCCCCCATGCCTGTGATGTTCCTCAAGGCCATTCCAGCAGATAAGCAAGATTGTCGAAGTGTCTATGCTTGTCCTGTGTACAAGACTTGTCAGCGGGGACCCACCTACGTGTGGACTTTCAATCTGAAGACTAAAGAAAACCCATCCAAGTGGGTTCTGGCTGGTGTTGCCTTGCTTCTCCAGATT
->Opossum
-ATGCCAGTGAAAGTG------GCGGCGGTGTTCTCCGAGGCTGAGGATGGAGATAGCGAGAAAGGG---CCAGATCCTAGAATACGGCTCCTGGGCACCTACGTGATTCGGTGCTTGCGGCCAGCGGCTGGCGCCTGGAAGCGCTGTGTGAGCACGGCCGAATCTGAGCAGCTGCTCCAGGCCTTCCTGACAGGCTACTGCCCTCAAGAG---------CCG------ATGTTGGTGGTGCGTCCTGGGGGTGGGGGTCTGCAGCTGAGCTCCGGG------------CCATACCCCGATTTGTCTCGAGCCAAAGCGCTGTTCTTCCTGCGC---GGTTCCCCCAATCCCCCAGGACCCTTGGGTCCCAAAGGCGCAGTGCTCTGCGGGGAGCTGGCCCCGGCACCGTTGGAGCATCTGGCCACGCTGGTGGCTGAGGTAGTGATGCCTGTCCTGACCAATGAAAAGAATCACCAAGACTGGCCAAATGCTTTATATCAGGATGTAAGACGACACATCCACCACCTTCAAAGTGACCTCATTATCTTCCTGGGTCAAGTGACAGGAAAAACATTGCTGCCTCTTCCAGTAGGCTCAGAAAACATGGAATGTGCGGATTATGAAAATGAAAAAGACTTGGATTTCACAGATAAATCAATTGTCTATGCTATTGAGTCCACAGTGATCAAATGGAGCCACCAGATTCAAATAGTATTAAAGAGGGAATCTTCAGAACCACTCTTGCAGGGAGGAAATCCCACCCCAAAAGTGGAGCTGGAATTCTGGAAGAGAAGGTGTGAAGATCTGGAATATATTTATAATCAGCTGAGAGCCATAGAAGTGAGGGGCATAGCTGCACTTTTAAACAGACTTCAGAGCAGCTACTTCCCAGCCTTCAAAACCATGTTCAAAGATGTAATAGCAGCTTTAAGAGAGGCCCAGGATATCTATGTACATCTGAAGCCCCTGCAACGCCATGTGGAAAACATAGAGAATGTGGAATTTAGTGAAGTGAAGCCACTGGTGGGACCCCTGCTTCACGTAATCTTCTTGATTTGGTCCACATCTAAATACTACTGCTGTCCAGTACGGATCATTGTGCTACTGCAGGAAATATATAACCTTCTCATTCAGCAGGCCTGTACATATCTTAGCCCAGAAGATCTACTGAAAGGGGAGATAGAAGAGAGTCAGAGGAAAATACAGGTGGTGATGGACATTCTTAACTTTTCCAAAGAGATGTTTGAGAATAGGAGGAACAATCTCAAGACTTACTTCAAACAGGTCCGGGAGGTGAAGGAATGGGATTTCAATTCTTCTATGATCTTTGTGCGACTAAATAACTTCCTCAAAAGACTCAAGATGGTAGAGAATCTTCTGAAGACAACCTTGGATTTTCTCAAGCTAGAGAAACTTGAATTCAGTGGAATTAGAGGGAATGCTTTGAGTCAACAAGTCCAGGGCATGTATGAAGAATTCCAGAATGTGTACAAAGCCTTTTCAGAATGCTTCTATGACTGTCTGGACCCTAAACACACAGAATTCGAAAATTATGTTGCTGAATTCAACCACAAAGTAGAAGATTTGGACCGAAGATTAGGGATGGTCTTCCTCCAAGCTTTTAATGATGTATCTGGCTTAGAGCATGCTTTTAAGTTGCTTGAAATATTTGGGAGTCTGCTTGAAAGACCAGTAGTAGCCATGGATGTATTTGATAAATACCCAAGACTGATCACAATGTTCAGCAGTGACTTGGATGCTGTTAAGACAATCTATTGTCAGCATGTCCAGGAGGAGTCAGAACTTGGGTTTTCCCAATTACACAAGAACATGCCGGCAGTAGCTGGGGGTCTCCGCTGGGCTCAGGAACTCAGAGAACGAATTGAAATTTCATTCAATAACCTAAGACATATCAATCACCCCTATATGGAGTCCACTGAAAGTAAAGAGATGTTCCAAAAGTATGGTGAAATGTTTACATTGTTAGAAAAGTATGAGACAAAACTTTATGATAGCTGGTGCCAGACAGTGTCAGAGAAGTCACAATACAATCTCACTCAGCCACTCCTCTGTCATGATCCAGAAACTAAGCAGATCATTGTCAACTTTAACCCACAG---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------GAAAAC---ATGAAA------------------------------------------------------------------------------------------------------------------------------------------------------CTCTTCCTTGCAGATCCAGCATCCAGTATGTGGAAGGCATACATTGACTACCTTGATAACATGGTTCTTCATGGATTCTTCATTGCTATTGAATCTTCTCTAAATTATCTCCTGGAAAATACTGATTCTAAGAACAGACTTCCTCCCTTTTTTGAAACACAATTGGATCTAGTTATACCAGAACTGATCTTTTGTCCCTCTCTGGACCCTTTTGCTAATGGTGGTTTTCAAAGCATTGTGGAGGGACTTATCAATGACATTTTCAAAATATCTTCTATGGTCCCACGACTT---GCACAGAAAAGTTCCCCTCATTATCAGGCTGACATGGAGGACACAGAAGATCTGTCAAACCTGAGGAATATATTAATGGAGAGAGTCAAGAATATGATGACCATCTGCTGTGACTATCGGAACTCCTTTGACCATTACTCTTTCCTTTACATGGATGACCGAAAGGAATTTATGCGACAATTTCTTTTATATGGACATATGCTCACACCAGAGGATTTAGAAGCCCATGGAGAAGATGAGATCCCTGAAAATCCTCCCACTCTTCAGCAATTTAAATTGCAGATTGATTCCTATGAAAAGATTTATGAAGAGGTGAACCAGCTAGAGCCTTTCAGAATTTTTGACAACTGGATGAAAATTGATATTCGTCCATTTAAGATGACTCTACTAAATGTAATTAAGAGATGGAGCTTCATGCTTAAACAGTATCTCATTGATCATGTCACTCACAGTTTGGCAGACCTTGAAGTCTTTATAAGAAATGGTGAGAGTGGTTTAAACAAGAAGATAGAAAAAGGTGATTTTGCTGGTTTGGTTGAAATTATGAGAACTCTAATGGCTCTTAAAGAACGACAGAGCAGCACTGATGAGATGTTTGAGCCACTGAAACACACAATTGATTTACTGAAGATCTATGAACAAGAATTACCTGATTCAGTATTTAAACAGCTAGAGGAATTGCCAGAAAAATGGAGCAACATAAAGAAGATGGCAGTCATTGTAAAACAGCATGTAGCTCCCCTGCAGGAAGATGAAGTAACAGCTCTCCGTCAAAAATGTGCCATTTTTGCTATTGAACAGAATATATTCCAAGATCAGTTCCACAAAGAAGCTCCTTTCAGGTATGATAGCATTAAGCCTCACCAAGTCTTGGATGCCAAAAACATTCAAATCCAACAGATGGAATCTTTCATGTCCTCCATTTCAGACTCTACAAATTTGTTTGAAGTCAACATTCCTGATTACAAACATTTAAAACAATGCAGGAAGGAGATCTGCTTGTTGAAGGAGCTTTGGGATATGATTGACCTAGTGAATTTTAGCATCAATAACTGGAAGGTAACCAAATGGAGGAATATTAATGTAGAGAATATGGACTTAGAATGTAAAAGTTTTGCCAAACAAATATGGAAACTTGGCAAGGATGTGAGAGCCTGGGATGCTTTCATGGGGCTGGACAACACTCTGAAGAACATCCTAACATCCTTACGGGCTGTGTCTGAACTTCAAAATCCAGCCATAAGAGAGAGGCACTGGAACCAGCTGATGCAGGCTACAGGTATGAAATTCATCATGAATGATGATACCACCCTTGAAGACTTACTTAAGCTTGAGCTACACAACTTTGAAGAGGCGATCCAGGGCATTGTAGACAAAGCTGTGAAAGAGATGGACATGGAAAAAGTTCTAAAGGAACTAAAAGCCACTTGGGCAGGGATGGAATTTCATTATGAGCCCCACCCCCGGACAATGGTCCCACTGATGAGGTCTGATGAAGACCTTATTGAAACTCTTGAAGATAACCAAGTCCAGCTGCAGAATCTAATGACATCCAAGTACATAGCCTTCTTCCTGGAGGAAGTATCTGACTGGCAGAAGAAGCTCTCAATAGCTGATGCTGTCATTTCAATCTGGTTTGAAGTACAGCGTACATGGTCTCATCTTGAAAGCATTTTCATTGGATCTGAAGATATACGAGCACAGCTTCCTAAGGACTCTAAACATTTTGAAGACATTGATACTGATTTTAAAGAGTTAGTTTGTGATGCTCAGAAGACACCAAATGTGGTAGAAGCTACCAACAAACCAGGTGTTCATGAACAATTAGAAGATATTCAGAACAGGTTGAGCCAGTGTGAGAAAGCCTTGACTGAATATCTAGATACCAAGAGACTGGTCTTCCCCAGGTTTTATTTCCTCTCCTCTTCCGACCTTTTAGACATCCTTTCCAACGGCACAAATCCACAACAAGTTCAACGCCATCTTTCTAAGTTATTTGACAGTATGGCTAGGATGAAGTTCCAGGTGGACTCCAGTCAAAAACCAACCAAGAAAAGCCTCGGCATGTATAGCAAAGAGGAAGAGTATGTGAATTTCAGTGAGCCTTGTGACTGTAGTGGCCAGGTTGAACTCTGGTTGAATAATGTGCTCAATCACATGAGGGCCACCGTGAGACATGAAATGACAGAAGGTGTCACTGCCTATGAAGAGAAACCTAGGGAACAGTGGCTCTTTGACTACCCTGCTCAGGTGGCCTTGACATGTACCCAGATCTGGTGGACCACTGAGGTGGGAATTTCCTTTGCCAGGCTGGAAGAAGGATATGAAAGTGCCATGAAGGACTATTATAAGAAACAAGTTACCCAACTGAACACCCTGATCACCATGCTAATTGGCCAGCTCTCCATGGGTGACCGTCAAAAAATCATGACCATCTGTACTATTGATGTGCATGCTCGAGATGTAGTTGCCAAGATGATCTCTCAGAAGGTAGAGAACACTCAGGCTTTTCTCTGGATGTCCCAGATGCGCCATCGGTGGGATGATGAGAAAAAGCACTGCTTTGCCAATATTTGTGATGCTGAATTCCTGTATTCCTATGAGTACCTGGGTAACACACCTCGCCTGGTGATTACCCCTCTGACA------GACAGATGTTACATTACCCTCACCCAGTCTTTGCATTTGACCATGAGTGGGGCTCCAGCAGGACCTGCAGGCACTGGCAAAACTGAGACTACCAAAGACCTGGGTCGAGCATTGGGTATCATGGTATATGTGTTTAACTGTTCTGAGCAAATGGACTACAAGTCTTGTGGCAATATCTACAAAGGCCTTTCTCAGACTGGTGCCTGGGGCTGTTTTGATGAATTTAACAGAATTTCTGTGGAGGTTCTTTCCGTGGTGGCAGTACAGGTGAAAAGTATTCAAGATGCAATCAGAGATAAGAAGCTGAATTTCAATTTCCTTGGAGAGGAGATTAAATTGAATCCCTCAGTGGGAATCTTCATCACTATGAACCCAGGATATGCTGGCCGTACAGAGCTTCCAGAGAACCTTAAGGCTCTCTTCAGGCCTTGTGCTATGGTGGTACCAGATTTTGAATTGATCTGTGAAATCATGTTGGTTGCTGAAGGATTCATCGAGGCACAATCATTGGCCAAAAAATTCATTACCCTTTATCAGCTTTGCAAAGAGCTCCTCTCCAAACAGGACCATTATGACTGGGGTCTGCGAGCTATCAAGTCTGTGCTTGTGGTAGCAGGATCTCTGAAGAGAGGAGACCCTGACCGACCTGAAGACCAAGTCCTAATGCGTTCCCTCAGAGACTTCAATATTCCCAAAATCACAACTGATGACATGCCTGTGTTTATAGGCCTAATTGGAGACCTTTTCCCTGCCCTTGACATCCCCAGAAAGAGAGACCTTCACTTTGAAAGTTTTGTAAAACAGGCAATATTAGAGCTAAAACTTCAGGCTGAGGACAACTTTATGCTCAAAGTGGTACAGCTAGAAGAACTTTTGGCTGTGCGACACTCTGTG---TTTGTGGTGGGGAATGCTGGT------ACAGGAAAATCCCAGGTACTAAGATCTTTGCAAAAGACATACCAG------AACATGAAACGACGACCAGTCTGGACTGATCTCAACCCCAAAGCTGTCACTAATGATGAACTATTT---------------------------------------GGCATCATCAACCCAGCCACAAGAGAATGGAAAGATGGA---CTTTTCTCATCAATCTTGCGTGAACTTGCCAATATAATACATGATGGGCCCAAGTGGATTTTACTAGATGGCGATATTGATCCAATGTGGATTGAATCTTTGAACACTGTCATGGATGATAACAAGGTTCTGACTCTGGCAAGCAATGAAAGAATCTCTCTCAATCCAACTATGCGGCTCCTGTTTGAGATCAACCACTTGCACACAGCTACCCCTGCCACAGTCTCCAGAGCAGGAATACTATACATCAATCCTGCAGACCTGGGTTGGAATCCACCAGTGAGTAGTTGGATTGACAAGAGAGAGATACAGTCTGAACGAGCTAACCTGACCATCCTATTTGACAAATATTTGCCACCTTGCCTGGATGTAGTCAAAACAAGATTTAAAAAGATTGTTCCAATACCAGAGCAGAGCATGATTCAAATGCTGTGTTACATTCTTGAGTGTCTTCTAACAAAGGAAAACAGTCCCCCAGACTCTCCCAAGGAACTTCATGAACTTTATTTTGTGTTTGCTTCTATCTGGGCTTTTGGTGGAGTATTGATCCAAGACCAGCTTGTGGATTACAGAGCAGAGTTCAGTAAATGGTGGATAACTGAATTCAAGACAATCAAGTTTCCTTCCCAAGGAACAATCTTTGACTTTTACATAGAACCAGAAACAAAGAAATTTGAGCCGTGGTCCAAACTTATCCCCAAATTTGAATTTGACCCAGACCTACCTTTGCAGACTTGCCTGGTACACACTGTTGAGACCATTCGTGTGTGCTATTTCATGGAGCAGCTCCTGAAACACCGGAGACCTATCATGTTGGTGGGGAATGCAGGCACTGGGAAATCTGTTCTGGTAGGGGCAAAATTGGCTACCCTGGATGCAGATGAATACATGGTGAAGAATATCCCATTTAATTATTATACTACATCTGCAATGCTACAAGCTGTCCTAGAGAAACCTCTAGAAAAGAAAGCTGGAAGAAATTATGGCCCACCTGGCACCAAGAAACTCATCTATTTCATTGATGATATGAACATGCCTGAGGTAGATGCATATGGAACAGTGCAACCCCACACACTCATCAGACAGCATATGGACTATGGGCACTGGTATGACAGAAATAAACTGTTCCTCAAAGAAATCATGAATGTACAATATGTGGCCTGTATGAATCCGACAGCTGGTGGCTTCTCTATCAATCCTCGGCTACAGCGTCATTTTAGCATCTTTGTGCTCTCCTTCCCTGGAGTAGATGCATTGTATTCAATCTATAGCACCATCTTGACTCAGCATCTAAAACTTGGTAACTTTCCAGCATCACTGCTGAATTCCACCCCCCGACTCATTAACTTGGCCATTACCTTCCATCAGAAGATTGCTGCCACTTTTCTCCCCACAGCAATAAAATTCCATTATATCTTCAATCTCCGAGATTTCTCCAACATTTTCCAAGGCATTCTCTTTTCAACAGTGGAAAGTGTTAAAACCACATCAGACCTTGTGAAGCTCTATCTTCATGAGTCCAATCGGGTTTATCGCGATAAGATGGTTGAAGACAATGACTTTGACAACTTTGATAAAATCCAAATTGAAGTGGTAAATAATTTCTTTGATGATATGGACAAGACTCTAGAGGAAATCAAGAGATTGAATATGTACTGCCACTTTGCAAATGGTATTGGTGAGCCCAAATATATGCCAGTGAAGACATGGGAACTGCTTACCCAAATCCTGGTGGAAGCCTTAGAGAACCACAATGAAGTCAATCAAGTGATGAATCTGGTTCTTTTTGAGGATGCCATGTGCCATGTTTGTCGTATCAATCGCATCCTAGAATCCCCAAGGGGGAATGCTTTGCTGGTTGGAGTAGGTGGAAGTGGCAAACAGAGCCTGACAAGACTTGCAGCTTTTATCAGCTCCATGGATGTTTTCCAGATCACTCTAAGAAAAGGTTATTGTATTTCTGATCTTAAGATGGATTTAGCCAATCAGTGCCTAAAAGCTGGAGTAAAGAATGTAAGCACTGTATTTCTCATGACAGATGCCCAAGTTGCTGATGAAAAGTTCCTTGTCCTTATCAATGATCTGTTGGCATCTGGAGAGATTCCAGATCTATACTCTGATGATGAAGTTGAAAACATCATAAACAATATGAGAAATGAAGTCAAGAGCCTGGGTTTGTTTGACAGCAGGGAAACTTGCTGGAAAGTCTTCATAGAAAGGGTCCAAAAACAATTAAAGGTTATACTCTGCTTCTCCCCTGTGGGGAATAAGCTAAGAGTCCGCAGCAGGAAATTTCCAGCCATTGTGAACTGCACAGCCATTGATTGGTTTCATGAGTGGCCTCAGCAAGCACTAGAATCAGTGAGCCTGCGCTTCTTACAAAACATAGAGAATATTGATCCAGCAGTAAAAGAGTCAATTAGTAAATTCATGGCTTATGTACACACGAGTGTCAACCAAATGTCCCAGTCCTACCTGAGCAATGAACGGCGCTATAATTACACCACCCCAAAATCCTTCCTGGAACAGATCAGACTCTATCAGAACCTACTGGTCAAGAATGGCAATGAGCTGACATCTAAAATGAAGAGGCTTAAGAATGGACTGCAGAAGCTTCACAGTACATCTTCCCAGGTAGATGACCTGAAAGCTAAACTGGCACTCCAGGAAATAGAGCTCAGGCAGAAGAATGAAGATGCAGACAAACTAATTCAAGTGGTTGGAGTAGAGACAGAGAAAGTAAGCAAAGAGAAAGCCATTGCTGATGAAGAGGAACATAAAGTGGCTCTAATCATGTTGGAGGTCAAGCAGAAGCAAAAGGACTGTGAGGAAGATCTGGCCAAAGCAGAGCCATCTCTCACAGCAGCCCAAGAAGCTCTCAACACACTCAATAAGACCAACCTAACAGAGCTCAAGTCTTTTGGTTCACCACCTTTGGCTGTCAGCAATGTCACTGCTGCAGTAATGGTTCTCATGGCCCCTGGAGGGAAGGTACCCAGAGATCGAAGTTGGAAAGCTGCCAAGGCTACCATGGCCCGAGTTGATGGCTTTCTGGACGCCCTGGTCAACTTTAACAAAGAGAACATACCTGAGAGCTGCCTCAAAGCTATCCAACCATATATTCAAGATCCAGAATTTAAACCTGAGTTTGTGGCCTCTAAGTCTTTTGCAGCAGCTGGCCTCTGTTCCTGGGTCATAAATATTGTGAGGTTTTATGAGGTTTTCTGTGATGTGGAACCCAAGCGGCAAGCCCTGAGTAAAGCAAGTTTGGATCTTGCTATTGCCCAAGAAAAATTGGCAACCATTAAAATCAAGATTGCTCACCTTAATGAAAACTTGGCAAAACTTACAACCAAATTTGAGAAAGCAACTGCAGAAAAACTCAAATGTCAGCAAGAAGCTGAACTGACCACAGGTACCATCTCACTTGCAAATCGCCTGGTTGGAGGTCTTGCCTCTGAAAATGTAAGATGGGCAGAAGCTATTAAGGACTTCAGACAGCAAGAGAATACATTGTGTGGAGATATTTTACTGATTACAGCTTTCATTTCTTACCTGGGATACTTTACCAAGAAATATCGTCAAAATCTTATGGATTGTAGCTGGAGACCTTACCTGAATCAGTTAAAAGTGCCTTTTCCAGTCACCCCTACTTTAGATCCTCTAAAGATGCTTACTGATGATGTAGACATAGCCACCTGGCAAAATGAGGGTCTTCCTGCTGACCGTGTGTCCACAGAGAATGCTACAATCCTTATCAACAGTGAACGATGGCCACTTATAGTTGACCCTCAACTACAAGGAGTCAAATGGATTAAGAAGAAATATGGCAAAGACCTTCGAGTCATCCAGATTGGAGAGAAAGGATACCTTGATATCATAGAACATGCCCTAGCAGATGGTGATGTAGTGCTGATTGAAAACATAGGAGAGACAGTGGACCCTGTTCTAGGACCCTTGTTGGGAAGAGAAGTAATTAAAAAAGGAAGATTCATTAAAATTGGAGACAAGGAGTGTGAATATAATCCCAGGTTCCGCCTCATTCTTCACACCAAGCTTGCCAATCCTCACTATCAGCCTGAGCTCCAAGCCCAGGCAACGCTTATCAACTTCACTGTGACTAGAGATGGCTTAGAGGATCAGCTTCTGGCAGCAGTGGTCAACATGGAGAGGCCAGACTTAGAAGAACTGAGATCAGATCTGACAAAGCAACAGAATGCATTCAAGATCACACTGAAAACCTTGGAAGACAACTTGCTGTCTTGCCTCTCCTCCGCATCTGGGAACTTCCTGGGAGATATGGCTTTAGTAGAAAACTTAGAGATCACCAAAAAGACAGCTACAGAAATTCAGAAGAAGGTCCAGGAAGCCAAGATAACAGAAATAAAAATTAATGATGCCAGAGAGCATTACCGGCCAGTGGCAGCACGTGCGTCTTTGCTGTACTTCATCATGAATGACCTCAGTAAAATCCATCCCATGTATCAGTTTTCTCTCAAGGCTTTCAGCCTTGTCTTCCAAAAGGCTATACAGAAGACCAAGGCAGATGCTGATGAGAACCTCCAACAGAGAGTAGTCAGTTTGATTGACAACATCACCTTCTCTGTATATCAGTATACTACTAGGGGACTTTTTGAATGTGATAAGCTGACTTACATCACCCAGGTCACCTTTCAGACACTCATGATGAATCAGGAAATCAATGCTGCTGAATTGGACTTCCTTCTCCGGTACCCAGCACAGTCCAATGTTCTGAGCCCTGTGGATTTCCTTTCCAACCAATCCTGGGGAGGTATCAAGACTCTTTCATTAATGGAAGAATTTTGTAATCTGGATCGAGACATTGAAGGGTCTGCCAAACATTGGAAAAAATTTGTGGACTCAGAGTGTCCTGAAAAGGAGAAATTCCCCCAAGCATGGAAAAACAAGTCATCTCTACAAAAACTGTGTATGATGAGGGCAATGAGACCTGACCGAATGACATATGCTATGAGAGATTTTGTGGAAGAAAAGCTAGGAAGCAAATATGTGGTGGGCAGAGCATTAGATCTCTCTACCTCTTTAGAAGAATCAGGGTCTGCAACTCCCATGTTCTTCATACTGTCGCCAGGTGTTGACCCACTGAAAGATGTGGAGAAGGAAGGGAAGAAACTTGGTTATACCTTCAACAACCAGAACTTCCATAATGTGTCCTTGGGTCAAGGACAAGAGGTAGTAGCAGAGGCTGCATTGGATCTGGCTGCCAAGAATGGCCACTGGGTTATCTTACAGAACATCCATCTGGTAGCCAAATGGCTTGGATCCCTTGAGAAGAAGTTGGAACAACATAGCAAGAGCAGTCATCATGAGTTCAGAGTCTTCATGAGTGCTGAGCCTGCAGCTTCTCCTGATGGTCACATCATTCCCCAAGGCATCCTAGAAAATTCAATAAAGATCACTAATGAGCCTCCCATGGGCATGCATGCCAAACTGCACAAGGCCCTGGACAACTTCACTCAGAATACTCTGGAAATGTGTACCCGAGAAACAGAGTTTAAGAGTATTTTATTTGCACTTTGTTACTTCCACGCTGTTGTAGCAGAAAGGCACAAATTTGGACCTCAAGGCTGGAATCGCACTTACCCTTTTAACACTGGAGACCTTACCATCTCAGTGAATGTGCTCTATAACTTTCTTGAGGCCAATGCCAAGGTACCCTATGATGACTTGCGCTATCTCTTTGGTGAGATCATGTATGGAGGTCACATCACAGATAACTGGGACAGGAGGCTTTGTAGAACATACCTGGAGGAATTCATTAAGCCAGAAATGTTAGAAGGAGAAATGTTTCTGGCTCCAGGGTTCCCGATGCCAGGCAATATGGATTACAACAGTTATCACCAGTTCATTGATGACATGCTGCCAACAGAGTCACCATATTTGTATGGGCTTCACCCCAATGCTGAAATTGGCTTTCTGACCCACACCGCAGAAAAGCTCTTCCATACAGTGCTAGAAATGCAGCCTCGGGACAGCCAAGATGGAGATGGAGGAGGGATCACAAGAGAAGAAAAGGTAAAAGCCTTTCTGGATGAAATATTAGAGAAGATAACTGAAGAGTTTAACATTGCAGAGTTGATGGCTAGGGTAGAAGAACGTACCCCCTACGTTGTGGTTACCTTTCAAGAATGTGAAAGAATGAACCTCCTTATCAGAGAAATACAGCACTCGTTGAAAGAACTGGATCTGAGTCTGAAGGGTGAGCTAACAATGACCAGCAACATGGAGAGCTTACAGAGAGCTCTGTACCTAGATACTGTACCAGCGTCGTGGGCCAAGAAAGCATACCCATCAACAGCAGGCCTGGCAAGCTGGATTGTGGATCTGCTCACCCGAATTAAAGAGCTGGAAAGATGGATGGGAGACTTTGCATTACCCTCTGCTGTCTGGCTAGCAGGATTTTTTAACCCCCAATCATTCCTAACGGCCATCATGCAGTCCATGGCTCATAAGAATAAGTGGCCACTGGATAAGATAGCCCTGCAGTGTGAAGTGACTAAGAAGAATCGGGAAGATTTCAGTAGCCCACCTCGGGAAGGGGCCTATATCTATGGTCTGTTCATGGAAGGGGCCTGTTGGGATACACAGGCTGGAAATATCACAGAGGCTAGACTGAAGGATCTGACTCCACTCATGCCTGTGATATTCATCAAAGCTGTCCCTGTGGACAAGCAAGACAATCGAAATATCTATCCTTGTCCAGTATACAAGACTTGTCAGCGGGGACCCACTTATATTTGGACATTTGGTCTGAAAACTAAAGAAGCTCCATCCAAATGGGTATTAGCTGGTGTGGCCTTGCTTTTGCAGATT
-"""
+_aln = {
+    "Human": "ATGCGGCTCGCGGAGGAGCGGGCCGCGCTC------GCGGCGGAGAACGCGGATGGGGAACCCGGC---GCCGACCGACGACTGCGACTCCTGGGGACCTACGTGGCCATGAGCCTGCGGCCGGCTGCGGGCGCCTGGGAGCGTTGCGCGGGGAGTGCTGAGGCGGAGCAGCTGCTCCAGGCCTTCCTG---GGCCGCGATGCTGCCGAGGGGCCGCGGCCG------CTGCTGGTGGTGCGGCCCGGGCCCAGGGGCCTGGCAATACGCCCCGGGCTGGAGGTGGGACCTGAGTCGGGCCTGGCTGGCGCTAAGGCGCTTTTTTTCCTTCGCACCGGG---CCCGAGCCTCCAGGGCCCGACAGCTTCCGCGGCGCAGTGGTCTGCGGGGACCTGCCCGCGGCACCTCTGGAGCACCTAGCCGCGCTGTTCTCGGAGGTTGTTCTACCCGTCCTGGCCAATGAGAAGAATCGCCTAAACTGGCCCCACATGATATGTGAGGATGTCAGGCGGCACGCCCACAGCCTCCAATGTGACCTCTCAGTTATACTTGAGCAAGTGAAGGGAAAAACTTTGCTGCCTCTTCCAGCAGGCTCAGAAAAAATGGAGTTTGCGGATTCCAAAAGTGAGACAGTCTTGGATTCTATAGATAAGTCAGTCATCTATGCCATTGAGTCTGCAGTGATCAAATGGAGCTACCAAGTCCAGGTGGTACTCAAGAGAGAGTCTTCCCAGCCACTCTTACAAGGGGAGAATCCCACCCCTAAGGTGGAGTTGGAGTTCTGGAAGAGCAGGTATGAAGATCTGAAATACATCTATAATCAACTGAGAACAATAACGGTGAGGGGCATGGCCAAGCTCCTGGACAAGCTTCAGAGTAGCTACTTTCCAGCTTTCAAAGCCATGTACAGAGATGTTGTTGCAGCTCTAGCAGAGGCACAGGACATCCATGTGCACCTGATACCGCTCCAGCGCCACCTGGAAGCTCTGGAGAATGCAGAATTTCCGGAGGTGAAGCCCCAGCTGCGGCCCCTGCTCCACGTGGTCTGTCTGATTTGGGCCACATGCAAGTCCTACCGCTCCCCGGGAAGGCTGACTGTGCTGCTCCAGGAGATTTGCAACCTTCTCATCCAGCAGGCCTCTAATTATCTCAGCCCAGAAGACCTGCTGAGAAGTGAGGTAGAAGAAAGTCAGAGAAAACTGCAAGTGGTCTCAGACACTTTGAGCTTCTTCAAGCAAGAGTTTCAGGACAGAAGGGAGAATCTCCACACTTACTTCAAAGAGAACCAGGAAGTCAAGGAATGGGATTTCCAGTCTTCTTTGGTCTTTGTGCGATTGGATGGCTTCCTGGGACAACTGCACGTGGTGGAGGGTCTTCTGAAGACGGCCCTGGATTTCCACAAACTGGGAAAGGTGGAGTTCAGCGGCGTCAGAGGGAATGCTCTGAGTCAGCAGGTCCAGCAAATGCATGAAGAATTTCAAGAGATGTACAGGCTTCTCTCAGGATCCTCCTCCGACTGCCTGTACCTCCAAAGCACGGACTTTGAAAATGACGTCTCTGAATTTAACCAGAAAGTAGAAGATCTTGACCGAAGATTGGGGACTATCTTTATTCAAGCTTTTGATGATGCACCTGGCTTGGAGCATGCCTTTAAGCTGCTAGACATAGCAGGAAACCTCCTTGAAAGACCGCTGGTAGCGAGGGATACATCTGATAAATACCTGGTCCTCATCCAAATGTTCAACAAAGATCTGGATGCAGTGAGGATGATCTACAGTCAGCACGTCCAGGAGGAAGCAGAACTTGGGTTCTCCCCGGTGCACAAGAACATGCCCACCGTGGCTGGCGGCCTCCGCTGGGCACAGGAGCTGAGGCAGCGCATCCAGGGTCCTTTCAGCAACTTTGGACGCATCACACACCCTTGCATGGAATCTGCAGAAGGAAAGCGAATGCAACAAAAATATGAAGATATGCTGTCATTGCTAGAAAAGTATGAGACAAGACTTTATGAGGATTGGTGCCGGACAGTATCAGAGAAGTCACAGTACAATCTTTCCCAACCACTTCTAAAACGTGACCCAGAGACGAAGGAGATCACTATCAACTTTAACCCACAGCTGATTTCAGTGCTGAAAGAAATGAGCTATCTTGAACCCAGAGAGATGAAACACATGCCTGAGACAGCAGCAGCCATGTTCTCCTCCAGGGATTTCTATCGGCAGCTTGTGGCTAATTTAGAGTTGATGGCAAATTGGTACAACAAGGTTATGAAAACTCTGCTGGAGGTGGAATTTCCATTAGTGGAGGAAGAGCTGCAAAATATTGATCTCCGCCTCAGAGCAGCAGAGGAGACTTTGAACTGGAAAACAGAAGGCATTTGCGATTATGTCACTGAAATCACCAGTAGTATTCATGATCTTGAACAAAGAATTCAGAAAACTAAAGACAATGTGGAAGAGATCCAAAACATCATGAAAACATGGGTGACTCCAATATTTAAGACAAAAGATGGAAAAAGGGAATCCCTTCTTTCTCTGGATGATCGGCATGATCGAATGGAAAAATATTACAATCTCATCAAGGAATCTGGCCTTAAGATCCACGCCCTTGTTCAGGAAAACCTGGGTCTATTTTCAGCAGACCCAACCTCCAATATCTGGAAGACTTATGTTAACTCTATTGACAATTTGTTGCTGAATGGATTCTTTCTTGCCATTGAGTGCTCCCTCAAGTATCTTCTGGAAAATACTGAGTGTAAGGCAGGACTTACCCCAATATTTGAAGCACAACTGAGTCTAGCCATCCCAGAGCTAGTTTTCTATCCGTCTCTGGAGTCTGGAGTGAAGGGGGGTTTCTGTGACATTGTTGAGGGTCTCATCACCAGCATTTTTAGGATACCATCTCTGGTGCCACGGCTTTCCCCACAAAATGGCTCTCCTCACTATCAGGTCGACCTGGACGGTATACCAGATTTGGCAAACATGCGGCGCACACTCATGGAGAGAGTCCAGAGAATGATGGGCCTCTGCTGTGGCTATCAGAGCACCTTCAGCCAGTATTCGTACCTCTATGTGGAGGACCGGAAGGAGGTTCTGGGTCAGTTTCTGCTGTACGGGCACATCCTCACTCCGGAAGAAATTGAAGACCATGTGGAAGATGGCATCCCAGAGAACCCTCCCCTCCTTTCTCAGTTTAAAGTGCAAATCGACTCCTATGAAACGCTCTATGAAGAGGTGTGCAGGCTGGAACCCATCAAGGTGTTTGACGGCTGGATGAAAATTGATATTCGACCCTTTAAGGCATCTCTGCTGAATATTATTAAGAGGTGGAGCCTCCTGTTCAAACAGCATCTTGTGGACCACGTCACTCACAGCTTGGCCAACCTGGATGCGTTTATAAAGAAGAGTGAGAGCGGCTTACTCAAGAAAGTTGAAAAAGGAGATTTCCAAGGCTTGGTTGAGATCATGGGACACCTTATGGCTGTTAAAGAACGGCAGAGTAACACTGATGAGATGTTTGAGCCCTTAAAGCAGACTATTGAATTGCTGAAGACCTATGAACAAGAATTGCCAGAAACAGTGTTTAAGCAGCTGGAGGAGCTGCCTGAGAAATGGAACAACATAAAAAAGGTGGCCATTACTGTGAAGCAGCAGGTGGCCCCACTGCAGGCAAATGAAGTGACACTCCTCCGCCAGAGGTGCACAGCCTTCGATGCAGAACAGCAGCAATTCTGGGAGCAATTCCACAAAGAAGCCCCGTTCAGGTTTGATAGCATCCACCCTCATCAAATGCTGGATGCCAGGCACATCGAGATCCAGCAGATGGAATCCACTATGGCCTCCATTTCTGAGTCTGCCAGCTTATTTGAAGTCAATGTCCCTGACTATAAGCAGCTGAGGCAGTGCAGGAAGGAGGTCTGCCAGCTGAAGGAGCTCTGGGACACCATTGGAATGGTGACCTCCAGCATCCATGCCTGGGAGACCACACCCTGGAGGAATATCAACGTGGAAGCCATGGAGTTGGAGTGCAAACAGTTTGCCCGGCATATCCGAAACCTGGACAAGGAGGTCAGGGCCTGGGATGCATTCACAGGCCTGGAAAGCACTGTGTGGAACACGCTGAGCTCCCTGAGGGCAGTAGCTGAGCTGCAGAATCCAGCCATCCGGGAGCGGCACTGGAGGCAGCTGATGCAGGCCACCGGTGTGAGCTTCACTATGGACCAGGACACCACCCTAGCGCACCTGCTGCAGCTCCAGCTGCACCACTATGAGGATGAGGTCCGGGGCATTGTGGACAAAGCTGCAAAAGAGATGGGTATGGAGAAAACCTTAAAGGAGCTGCAGACTACCTGGGCTGGCATGGAATTCCAGTATGAGCCCCACCCACGGACCAATGTCCCCCTCCTGTGCTCTGATGAGGACCTCATAGAGGTTCTGGAGGATAATCAAGTTCAACTTCAGAACCTGGTGATGTCCAAGTATGTTGCTTTCTTCTTGGAGGAGGTGTCGGGCTGGCAGAAGAAGCTGTCCACAGTGGACGCTGTCATCTCTATCTGGTTTGAAGTGCAGCGAACATGGACTCACCTGGAAAGCATATTCACTGGATCTGAAGATATTCGGGCACAGCTACCCCAGGATTCTAAAAGGTTTGAAGGCATCGACATTGACTTTAAAGAGCTAGCTTATGATGCCCAGAAAATTCCAAATGTAGTGCAAACCACCAACAAGCCAGGCCTGTATGAAAAGCTGGAGGATATTCAGGGCAGATTGTGCCTGTGTGAGAAGGCCCTGGCAGAGTACCTCGACACCAAGAGGCTTGCCTTCCCGCGGTTTTACTTTCTCTCCTCCTCCGATCTGTTAGACATCCTTTCCAACGGCACAGCTCCACAACAGGTTCAACGTCACCTTTCCAAACTCTTTGACAACATGGCCAAGATGCGATTCCAGCTAGATGCCAGTGGGGAACCAACCAAGACAAGCCTCGGCATGTACAGCAAAGAAGAGGAGTATGTGGCTTTCAGTGAGCCCTGTGACTGCAGCGGGCAGGTAGAAATATGGCTGAACCATGTCCTTGGTCACATGAAGGCCACTGTGAGGCATGAGATGACAGAAGGTGTAACTGCCTATGAAGAAAAGCCGAGGGAGCAGTGGCTTTTTGACCACCCAGCTCAGGTGGCCCTGACCTGTACTCAGATCTGGTGGACAACAGAAGTGGGCATGGCATTTGCCAGGCTGGAGGAAGGCTATGAGAGTGCCATGAAGGACTATTATAAGAAGCAAGTGGCCCAGCTCAAAACCCTTATCACCATGCTGATTGGCCAGCTCTCCAAGGGAGACCGGCAGAAGATTATGACTATATGCACCATCGATGTGCATGCCCGGGATGTGGTAGCCAAGATGATTGCTCAGAAGGTAGACAATGCCCAGGCTTTCCTCTGGCTGTCTCAGCTGCGCCATCGTTGGGATGACGAGGTCAAACACTGCTTTGCCAACATCTGTGATGCCCAGTTTTTGTATTCCTATGAGTACCTGGGAAACACACCTCGCTTGGTGATCACACCTTTGACT------GACAGGTGCTACATCACCCTCACCCAGTCCCTGCACCTGACCATGAGTGGGGCTCCCGCAGGACCTGCAGGCACAGGCAAGACCGAGACCACCAAGGACCTGGGCCGCGCACTGGGCATCCTGGTCTATGTGTTCAACTGCTCGGAGCAGATGGATTACAAGTCTTGTGGCAACATCTACAAAGGCCTTGCTCAGACTGGTGCCTGGGGCTGCTTTGATGAGTTTAATCGAATCTCCGTGGAGGTCTTGTCAGTGGTGGCAGTGCAGGTAAAAAGCATTCAAGATGCGATTAGAGATAAGAAGCAGTGGTTCAGCTTCCTTGGGGAGGAGATCAGCCTGAATCCTTCTGTCGGTATCTTCATCACCATGAACCCAGGCTATGCTGGCCGCACAGAGCTGCCAGAGAATCTCAAGTCTCTCTTCAGGCCTTGTGCAATGGTGGTTCCAGACTTTGAATTGATCTGTGAAATCATGCTGGTGGCAGAAGGATTCATTGAAGCCCAGTCATTAGCCAGAAAGTTCATCACTCTTTACCAGTTGTGCAAAGAGCTTCTCTCCAAACAGGATCACTACGACTGGGGCCTACGGGCCATCAAGTCCGTGCTGGTGGTGGCAGGATCCCTGAAGAGAGGAGACCCTGACCGGCCTGAGGACCAGGTCCTGATGCGCTCCTTGCGGGATTTCAACATCCCCAAGATTGTGACTGATGACATGCCCATCTTCATGGGCCTGATCGGGGACCTCTTTCCCGCCCTGGATGTCCCCCGGAGGAGAGACCCCAACTTCGAAGCTTTGGTTAGGAAGGCGATAGTGGATCTGAAGCTCCAGGCTGAGGACAACTTTGTGCTCAAGGTGGTCCAGCTGGAGGAGCTCCTGGCTGTGCGGCACTCTGTA---TTTGTGGTGGGTGGCGCTGGT------ACCGGCAAGTCACAGGTGCTGAGGTCCTTGCACAAGACCTATCAG------ATCATGAAACGGCGCCCCGTCTGGACTGACCTCAATCCCAAAGCAGTCACAAATGATGAGCTCTTT---------------------------------------GGCATCATCAATCCAGCCACAGGAGAATGGAAGGATGGA---TTGTTCTCTTCCATCATGCGGGAGCTTGCCAACATCACCCATGATGGGCCCAAGTGGATTTTACTGGATGGCGACATAGATCCAATGTGGATTGAATCCCTGAATACTGTCATGGATGATAACAAGGTGCTGACATTGGCCAGCAATGAGAGGATTCCTCTGAACCCCACCATGAAGCTCCTCTTTGAGATCAGCCACCTGCGCACAGCCACTCCAGCAACTGTCTCTAGAGCAGGGATCTTGTACATCAACCCGGCAGACTTGGGATGGAACCCTCCAGTGAGCAGCTGGATTGAGAAGAGGGAAATCCAGACAGAGAGAGCCAACTTAACCATTTTGTTCGACAAGTATCTTCCAACCTGCCTAGACACACTCAGAACCAGGTTTAAGAAGATCATTCCCATCCCAGAGCAGAGCATGGTTCAGATGGTGTGTCACCTTCTGGAATGTCTCCTGACCACGGAGGACATCCCTGCAGACTGCCCTAAGGAAATTTATGAGCATTATTTTGTGTTTGCTGCCATCTGGGCTTTCGGCGGAGCAATGGTCCAAGATCAGCTTGTGGACTACCGGGCAGAGTTCAGCAAATGGTGGCTGACTGAGTTCAAAACAGTCAAGTTTCCTTCCCAAGGAACCATCTTTGACTATTACATCGACCCAGAGACCAAGAAATTCGAGCCTTGGTCCAAGCTCGTCCCCCAGTTCGAATTTGACCCCGAGATGCCCTTGCAGGCGTGTTTGGTGCACACGAGTGAGACCATCCGTGTGTGCTACTTCATGGAGCGGTTGATGGCGCGGCAGCGGCCTGTCATGCTGGTGGGCACGGCTGGCACTGGCAAGTCGGTGCTGGTGGGAGCTAAGCTGGCCAGCCTTGACCCCGAGGCATACCTGGTGAAAAACGTGCCATTCAACTACTACACCACGTCAGCAATGCTGCAGGCTGTCCTGGAGAAGCCTCTGGAAAAGAAGGCTGGCAGAAACTATGGCCCTCCAGGGAACAAGAAACTCATCTATTTCATTGATGACATGAACATGCCTGAGGTGGATGCCTACGGGACGGTGCAGCCCCACACCATCATCCGGCAGCATCTGGACTATGGCCACTGGTATGATCGGAGCAAGCTGTCCCTAAAGGAGATCACAAATGTACAGTATGTTTCCTGTATGAACCCCACGGCAGGCAGCTTCACCATCAACCCCCGGCTTCAGCGTCACTTCAGCGTGTTTGTCCTCTCCTTCCCGGGGGCAGATGCCCTGTCCTCTATCTACAGCATCATCCTCACTCAGCATCTGAAGCTCGGAAACTTCCCGGCGTCCCTGCAGAAATCCATCCCCCCACTGATCGATCTGGCCCTCGCCTTCCACCAGAAAATTGCTACCACCTTCCTACCCACAGGAATCAAATTCCACTACATCTTCAACCTCAGAGATTTTGCCAACATTTTCCAGGGCATTCTCTTCTCCTCAGTGGAATGTGTGAAATCCACATGGGATCTTATAAGGCTCTATCTGCATGAATCAAATCGAGTTTATCGGGATAAGATGGTAGAAGAAAAGGACTTTGATCTTTTTGATAAAATCCAGACAGAAGTGCTCAAGAAAACTTTTGATGATATTGAAGACCCTGTGGAGCAGACCCAAAGCCCGAACCTGTATTGTCACTTTGCAAATGGTATTGGGGAGCCCAAATACATGCCTGTACAGTCTTGGGAACTTTTGACCCAGACTCTGGTGGAGGCCTTGGAGAACCACAATGAAGTCAACACAGTGATGGACCTAGTTCTCTTTGAGGATGCCATGCGCCATGTCTGCCATATCAATCGCATCTTGGAGTCCCCGCGGGGAAATGCTCTGCTGGTTGGTGTAGGTGGGAGCGGCAAGCAGAGCCTGACAAGGCTGGCAGCTTTCATCAGCTCCATGGATGTCTTCCAGATCACACTGCGCAAAGGCTACCAGATCCAGGACTTCAAGATGGACCTGGCCAGCCTGTGTCTGAAAGCTGGAGTGAAGAATCTCAACACAGTGTTTCTCATGACTGATGCCCAAGTGGCTGATGAGAGGTTCCTTGTGCTCATCAATGATCTTTTGGCATCTGGGGAGATCCCAGATCTCTACTCTGATGATGAAGTTGAAAACATCATAAGCAATGTGAGGAATGAAGTCAAGAGCCAGGGTCTGGTTGACAACAGAGAGAACTGTTGGAAGTTCTTTATAGATCGGATCCGGCGACAGCTGAAGGTGACTCTCTGTTTCTCCCCTGTGGGAAACAAGCTAAGAGTCCGCAGCAGGAAGTTCCCAGCCATTGTGAACTGCACAGCCATCCACTGGTTCCACGAGTGGCCTCAGCAAGCATTGGAGTCTGTCAGCCTCCGCTTCTTGCAGAACACAGAGGGCATTGAGCCCACAGTAAAGCAGTCGATTAGCAAATTCATGGCCTTTGTCCACACAAGTGTCAACCAAACATCCCAGTCTTATCTGAGCAATGAACAGCGCTACAACTATACAACTCCCAAGTCCTTTCTGGAGTTCATCAGACTCTACCAGAGCTTGTTGCACAGGCACAGAAAAGAGCTCAAGTGCAAGACAGAGCGGTTGGAGAACGGGCTGCTGAAGCTGCATAGCACCTCTGCCCAGGTGGATGATCTGAAAGCAAAGCTGGCTGCCCAGGAAGTAGAGCTGAAGCAGAAAAATGAAGATGCAGACAAACTGATTCAGGTCGTGGGTGTGGAGACTGACAAAGTGAGCAGAGAGAAAGCCATGGCAGATGAAGAGGAGCAGAAGGTGGCCGTCATCATGCTAGAGGTGAAACAGAAGCAGAAGGACTGTGAGGAGGACCTGGCAAAGGCTGAGCCAGCACTCACAGCAGCGCAGGCAGCTCTCAACACCCTGAACAAGACCAACCTGACAGAGCTGAAGTCATTTGGCTCTCCGCCTCTGGCCGTCAGCAATGTCAGCGCTGCGGTGATGGTACTGATGGCTCCCAGGGGTAGGGTGCCCAAGGACCGGAGCTGGAAGGCTGCTAAGGTCACCATGGCCAAAGTGGATGGCTTCCTGGACTCGCTAATAAACTTCAACAAAGAGAACATTCACGAGAACTGCCTCAAAGCCATCAGGCCGTATCTGCAAGACCCCGAGTTCAATCCTGAGTTTGTGGCCACCAAATCCTATGCGGCTGCAGGCCTCTGCTCCTGGGTCATCAATATTGTGAGATTTTATGAGGTGTTCTGTGATGTGGAACCCAAGCGCCAGGCACTGAACAAAGCCACCGCGGACCTCACAGCTGCCCAGGAGAAGCTGGCTGCCATCAAAGCCAAGATCGCTCACCTTAATGAAAACCTGGCAAAGCTCACAGCCAGGTTTGAGAAAGCAACAGCAGACAAACTCAAATGTCAGCAAGAAGCCGAAGTGACCGCAGTCACCATCTCCCTTGCCAACCGCCTGGTTGGAGGACTCGCTTCTGAAAACGTGAGGTGGGCAGATGCCGTGCAGAACTTCAAACAGCAGGAAAGGACGTTATGTGGAGACATTTTACTTATAACGGCTTTCATTTCCTACCTTGGCTTCTTCACAAAGAAATACCGGCAGAGCCTCCTGGACAGAACTTGGAGGCCCTACCTGAGCCAGCTGAAAACTCCCATTCCAGTCACCCCAGCCCTGGATCCCCTGAGGATGCTGATGGATGATGCTGACGTGGCTGCCTGGCAGAACGAGGGCCTCCCAGCCGACCGCATGTCCGTGGAGAATGCCACCATTCTCATCAACTGTGAGCGCTGGCCACTCATGGTTGACCCTCAGCTACAAGGCATCAAATGGATCAAGAATAAATATGGTGAAGATCTCCGGGTCACGCAGATTGGTCAGAAAGGCTACCTTCAAATCATAGAGCAGGCCCTGGAAGCTGGAGCTGTGGTGCTGATTGAAAATCTAGAGGAGTCCATTGATCCTGTTCTGGGACCCCTGCTTGGGAGAGAAGTCATTAAAAAAGGACGATTCATTAAAATTGGAGACAAAGAATGTGAATACAATCCCAAGTTCCGGCTCATCCTCCACACCAAGCTGGCTAATCCTCACTACCAGCCTGAGCTGCAGGCTCAGGCCACCCTGATCAACTTCACCGTGACCAGGGATGGCCTGGAGGACCAGTTGCTGGCCGCTGTGGTCAGCATGGAGAGGCCAGACTTGGAGCAGCTGAAGTCCGATCTCACAAAGCAGCAGAATGGATTCAAAATTACCCTGAAAACGTTGGAAGACAGTCTTCTCTCTCGCCTCTCCTCCGCCTCTGGGAACTTCCTGGGAGAAACAGTGCTGGTGGAAAACCTAGAGATCACCAAGCAGACTGCTGCCGAAGTTGAGAAAAAGGTCCAGGAGGCCAAGGTGACTGAAGTGAAAATCAACGAGGCCCGAGAGCACTACCGGCCAGCAGCTGCCAGGGCCTCACTGCTCTACTTCATCATGAACGACCTCAGCAAGATCCATCCAATGTACCAGTTTTCTCTCAAGGCCTTCAGTATCGTCTTCCAGAAGGCTGTGGAG------AGGGCTGCTCCTGACGAAAGCCTCAGGGAGCGGGTGGCCAACCTAATAGACAGCATAACCTTCTCTGTGTACCAGTACACCATCCGCGGGCTCTTTGAGTGTGATAAGCTGACCTACCTTGCCCAGCTCACCTTTCAGATTCTCCTCATGAACCGAGAAGTCAATGCAGTGGAGTTGGATTTCCTGCTTCGATCTCCAGTGCAGACGGGCACCGCCAGCCCCGTGGAGTTCCTCTCCCATCAGGCGTGGGGAGCTGTCAAGGTACTTTCATCAATGGAAGAATTCTCTAATCTGGATCGGGACATAGAGGGATCTGCTAAGAGCTGGAAAAAGTTTGTGGAGTCCGAATGTCCTGAGAAAGAGAAGCTCCCACAGGAGTGGAAGAACAAGACAGCCCTGCAGCGCCTCTGCATGCTGAGAGCCATGCGGCCCGACCGGATGACCTATGCTTTGCGAGATTTTGTTGAAGAGAAGTTAGGAAGCAAATACGTGGTGGGAAGAGCCCTAGATTTTGCAACCTCATTTGAAGAATCGGGACCAGCCACTCCTATGTTTTTCATCCTGTCTCCAGGGGTGGACCCACTGAAGGATGTAGAAAGTCAAGGAAGAAAACTTGGATACACCTTCAACAATCAGAACTTTCACAACGTGTCTTTGGGGCAAGGACAGGAAGTGGTGGCTGAGGCTGCGCTGGACCTCGCTGCCAAGAAAGGTCACTGGGTTATTTTGCAGAACATTCACCTGGTGGCCAAGTGGCTCAGCACCCTGGAGAAGAAGCTGGAGGAGCACAGTGAGAACAGCCACCCAGAGTTCAGGGTCTTCATGAGTGCAGAGCCAGCACCCTCCCCTGAGGGCCACATCATCCCCCAGGGCATCCTGGAGAACTCCATTAAGATCACCAATGAGCCCCCCACGGGCATGCATGCCAACCTGCACAAGGCCCTGGACAACTTCACTCAGGACACTCTGGAGATGTGTTCTCGGGAGACGGAGTTTAAGAGCATCCTCTTTGCTCTTTGTTACTTCCATGCGGTGGTGGCAGAAAGACGAAAATTTGGGCCCCAGGGATGGAATCGCTCATACCCCTTTAACACTGGAGACCTCACTATCTCTGTGAATGTCCTCTACAACTTCCTGGAGGCCAACGCAAAGGTCCCCTATGATGATTTGCGCTACCTGTTTGGAGAGATCATGTATGGAGGCCATATCACAGATGACTGGGACAGAAGACTCTGCAGAACCTACCTGGGGGAATTCATTCGACCAGAAATGTTAGAAGGAGAACTGTCTTTGGCCCCAGGGTTCCCACTCCCAGGCAACATGGACTACAATGGTTATCATCAGTACATCGATGCTGAGCTGCCCCCAGAATCCCCCTACCTCTATGGCCTCCACCCGAACGCAGAGATTGGCTTCCTGACCCAAACCTCAGAAAAGCTCTTCCGCACTGTGCTGGAGCTGCAGCCTCGGGACAGCCAGGCCAGAGACGGAGCGGGCGCCACAAGAGAAGAAAAGGTCAAGGCACTTCTGGAAGAAATATTGGAGCGGGTGACAGACGAGTTTAACATCCCAGAACTGATGGCCAAAGTGGAGGAGCGCACCCCTTACATTGTAGTTGCCTTCCAGGAGTGTGGCCGGATGAATATCCTCACCAGAGAGATTCAGCGCTCACTGAGGGAGCTGGAGCTCGGCTTAAAGGGGGAGCTGACTATGACCAGCCACATGGAGAACTTACAGAATGCCCTGTACTTCGATATGGTGCCAGAGTCCTGGGCTAGACGAGCCTACCCTTCCACAGCAGGCCTGGCAGCCTGGTTTCCAGACCTCCTCAACAGAATCAAGGAGCTAGAGGCTTGGACGGGTGACTTTACAATGCCCTCCACTGTGTGGCTGACAGGCTTCTTCAACCCCCAGTCGTTCCTGACTGCCATCATGCAGTCCACGGCTCGCAAGAATGAGTGGCCACTGGACCAGATGGCCCTGCAATGTGACATGACGAAGAAGAACAGAGAAGAGTTTAGGAGTCCTCCTCGGGAAGGGGCCTACATCCATGGCCTCTTCATGGAAGGTGCCTGCTGGGACACACAGGCTGGGATCATTACAGAGGCAAAGCTGAAGGATCTGACACCCCCTATGCCTGTGATGTTCATCAAGGCCATTCCTGCAGATAAGCAGGACTGCCGCAGTGTCTATTCCTGTCCTGTGTACAAGACTAGTCAGCGGGGACCCACCTACGTGTGGACTTTCAACCTGAAGACTAAGGAAAACCCATCCAAGTGGGTTCTGGCTGGAGTAGCCTTGCTTCTCCAGATT",
+    "Mouse": "ATGCCCGGCGCCAAGGAGCAGGCAGCGCTG---------GCGGAGTCTGGGGACGAGGAGCCTGGA------GACCCGAGGCTGCGGCTTCTGGGGACTTTTGTGGCTCGGAGCCTGCGTCCGGCCGCGGGCACCTGGGAGCGCTGTGCAGGCACAGCCGAGGCGGGGAGGCTGCTGCAGGCCTTCCTG---GATCACAACGCTGCCTCGGATCCGCGGCCA------CTGCTGGTGGTTCAGTCCGGGCCCGGGGGCCTGGTGGTGACACCCGGTCTAGACGCAGGACCAGAGCCCAGCCGAGCTCGCGCCAAGGGGCTCTTTTTCTTGCGCACTAAG---TCCGAGCCTCCGGGAAATCACAGCCTCCGCGGCACGGTGCTCTGCGGGGACCTACCCGCGGTGCCACTGGAGCACCTGGCCCCGCTGCTCTCAGAGGTCATTATTCCTGTCCTGGCAAATGAAAAGAACCATTTAGAATGGCCCCACATGGTATGTCAAGACATCAGACATCATGCCCACACCCTGAAGTCTGACCTCCTAGTGATCTTTGAGCACATGAAGGGGAGAACCTTGCTGCCTCTTCCAGTTGGCTCAGAAAAACTGGAGTTTGTGGATGGCCACAGTGAGCCAGTCTCAGATGCCATAGACAAGTCAACTCTCTATGCTGTGGAGTCTGCAGTGATCAAATGGAGCCACCAAGTCCAGGTGGTACTCAAGAGGGAGTCTTCTCAGGCACTCATACAAGGACAAAATCCCACCCCCAAGGTGGAGCTGGAGTTCTGGAAGAGCAGGTGTGAGGACCTGGAACACATTTATAATCAACTAATGACAATCAAGGTGAAGGGAATGGCTGAACTCCTGGACAAACTTCAGAGCAGCTACTTGCCAGCTTTCAAAGCCATGTTCAGAGACGTTGAAGCAGCCCTGACCGAGGCCCAGGACATCCATGTGCACCTGTTACCTCTCCAGCAACACCTGGACATCCTGGAAAACGTGGAGTTTCCCAAGGTGAAGGGCAGGCTGCGGCCTCTGCTCCATGTGGTCTGTCTGATTTGGGCCACCTGCAAATGGTACCGTTCCCCTGGGAGGCTCACAGTGCTGCTCCAAGAAATCTGCAACCTCCTCATCCAGCAGGCCTCTAATTACCTCAGCCCAGAAGACCTCCTGAGAAGTGAGGTGGAAGAGAGTCAGAAAAAACTGCAAGTGGTCTCAGATACCTTAAGCTTCTTCAAACAGGCATTCCAGGACAGAAGGGAGCACCTCCACACTTACTTCAAGGAGGATTCTGAAGTCAGGGTGTGGGATTTCCAAGCATCTCTGGTGTTTGTGCGACTGGATGGCTTTCTGGGCCGAGTGCACATGGTGGAGGATCTTCTGAAGACAGCCTTGGATCTCAACAATCTGGAAAAGCTTGAGTTCAGTGGCCTCAGAGGAAACTCCCTGAGTCAGAAAGTCCAACGCATGCATGAGGAATTTGAGGAGATGTACAAGGTCTTCTTGGACTGCTCCTATGACTGTTTGGACCCCAAGGGCACGGAATTTGAAAATGATGTCTGTGAGTTTAACAAAAGAGTGGAAGATCTTGACCGGAGACTGGGGACTATCTTAATTCAAGCTTTTGATGATGCACCTGATGTGGAACATGCCTTTAAGCTACTGGACATCACAGGAACCCTCATCAAAAGACCCCTGGTAGCACAGGATGTATCACAAAAATACCTGGCCCTCATCCGAATGTTCAGCACAGAACTGGATGCTGTGAGGGTCATCTACAGTCAGCACATCCAGAAGGAGGCAGAGCATGGATTCTCCCCCGTGCACAAGAACATGCCCACTATGGCTGGCGGCATCTGCTGGGCACAGGAACTGAGGCAGCGCGTCAAGGGTCCCTTTGGCAACTTCAAAAACATACCACATCTGTACTTGCAATCTGCTGAAGGAAAGCGAATGATACAAAAATACGAAGACTTGCTCTCCCTGCTAGAAGAGTATGAGAGAAGACTTTATGAGGACTGGTGTCAGACGGTATCTGAAAAGTCACAGTACAATCTTTCCCTACCTCTTTTGCATCGTGACCCCAACACAAAGCAGCTCTCTGTCAACTTTAACCCACAGCTGATTTCAGTGTTGAAAGAAATGAACTATCTTCAGCCCAGTGAGGTGAAAACCATCCCCGAGACCGCAGCAGCCATGTTCTCCTCCAGGGAATTCTATCGTCAGCTTGTGGCCAACTTGGAGTTGATGGCAAATTGGTACAACAAGGTTATAAAAATTCTGCTGGAGGTGGAATTTCCACTAGTGGAGGAAGAACTGCAAAATATTGATCTCCGCCTGAGAGCTGCAGAGGAGACTCTGAGCTGGAAAACAGAAGGCATTTGGGATTATGCTATGCAAATAACCAATAGCATTCATGACCTGGAACAAAGAATTCAGAAGACAAAAGACAATGTGGAAGAGATTCAAAACATCATGAAAACATGGGTGTCTCCAATATTCAAGAGAAAAGATGGGAAAAAAGAATGGCCCCTTTCTCTGGATGATCAGCAGGATCACATGGAAAAATACTACAGTCTCATCCAGGAATCTGGCCTTAAGATTCACGCTCTTGTTCAGGAAAACCTGGTTCTGTTTGCAGCAGACCCAGCATCCAGCATTTGGAAGTCTTACGTGAACTACATTGATTCCATGTTGTTGGATGGATTTTTTCTTGCCATTGAGTGTTCTCTCAAATATCTATTGGAAAACACTGAATGCAAGCCTGGACTCACCCCAGTATTTGAAGCACAGCTCAACCTTGTCACCCCAGAATTAGTTTTCCACCCCTCTCTGGACTCTGGGGTAAAGGGAGGCTTATATGACATTGTCCAGAGTCTTGTCACCAGAATTTTTGCTATGCCATCCCTCGTGCCACGGCTTTCCCCACACAGTGGCTCTCCTCACTATCAGGGTGACCTAGAGGACATGGCCGACTTAGCTGGTCTTCGGAGTGTGCTCATGGAGAGGGTACAGAATATGATGACCCTCTGCTGTGGCTATAGAAATACCCTCAGCCAGTATTCTTACCTGTATGTGGAGGATAGGAAGGAGATTCTTGGTCAGTTTCTGCTCTATGGGCATGTCCTCACACCTGAAGAGATAGAAGCCCATGCCGAAGACGGCATTCCAGAAAATCCACCCCTCCTCCATCACTTCAAAGACCAGATAGACTCCTATGAAAAGCTCTATGAGGAGGTGGTCAGCCTGGAACCCACCAAGGTGTTTGATGGCTGGATGCGAGTGGATGTGAGACCCTTCAAAGCATCTCTGCTGAACACAATAAAGAAGTGGAGCCTCATGTTCAAGCAACATCTTGTTGACTTTGTCACAAACAGCCTGTCTGACCTTGACTCATTCATAAGGAGCACCGAGAGTGGTTTGCTCAAGAGGGTGGAGAAAGGAGATTTCCAAGGATTGGTTGAGATCATGGGACATCTTGTCACCCTTAAAGAACGGCAGAGCAGCACCGATGACATGTTTGAGCCCCTGAAGCAAACGATTGAACTGCTGAAGTCCTACGAACAAGAGCTGCCAGAAACCGTGTTTAAGCAACTGGAGGAGCTTCCTGAGAAGTGGAAGAACATGAAGAAGATGGCCATCACTGTGAGGCAACAGGTGGCCCCTCTGCAGGCAAATGAAGTGGCCCTACTCCGCCAGCGGTGCTCAGCCTTCGATGATGAGCAGCAGCAATTCCAGGAGAGGTTCCGCAAAGAGGCCCCTTTCAGGTTTGATAGTATCAATCCACACCAAATGCTGGATGCCTGGCACGTGGAGATCCAGCACATGGAATCCACCATGGCAACCATCTCTAAGTCGGCTGATTTGTTTGAAGTCAATGTTCCTGACTACAAGCAGCTGAGGCAGTGCAGGAAGGAGGCCTGCCAGTTAAAGGAGCTCTGGGACACCATTGGAATGGTGACCTCCAGCATCCGTGCCTGGGAGGCCACCAGCTGGAGGAATATCAGTGTGGAAGCCATGGACTCAGAGTGCAAGCAGTTCGCCCGGCACATCCGCAACCTAGATAAGGAGTTCAGGTCCTGGGATGCATTCACGGGCCTGGAAAGCACAGTGTTGAACACCCTGACGTCCCTGAGGGCTGTGGCGGAGCTGCAGAATCCTGCCATCCGGGATCGGCACTGGAGGCAGCTGATGCAGGCCACCGGGGTGAATTTCACCATGAATCAGGATACCACCTTAGCTCATCTCCTGCAGCTTCAGCTCCACCACTTCGAGGATGAGGTCCGAGGCATTGTGGACAGAGCTGTCAAAGAGATGAGTATGGAGAAGACCTTAAAGGAATTGCAGACTACCTGGGCCAGCATGGAATTCCAGTACGAGTCCCACGCAAGAACCCGCGTACCCTTGCTGCAGTCAGATGAGGATCTCATTGAGGTCCTAGAGGACAATCAAGTGCAACTTCAGAACCTGATGATGTCCAAATATGTTGCTTTCTTCCTGGAAGAAGTGTCGAGCTGGCAGAAGAAGCTGTCCACGGCTGACTCGGTCATCTCTATCTGGTTTGAGGTGCAGCGCACCTGGTCTCACCTAGAGAGCATATTCATTGGCTCAGAAGATATCCGGGCTCAGCTACCCCAGGACTCTAAGAGATTTGAAGGCATTGACTCTGACTTCAGAGAGCTGGCGTATGATGCTCAGAAAACCCCAAATGTGGTGGAAGCCACAAATAAGTCAGGTCTCTATGAAAAGCTGGAGGATATACAAAGCAGATTATGCCTGTGTGAGAAAGCCCTAGCAGAGTATCTAGACACCAAGAGGCTCAGCTTCCCTCGCTTTTACTTCCTGTCCTCCTCTGACCTGCTGGACATCCTTTCCAATGGCACAGCTCCACAACAGGTTCAACGGCACCTCTCCAAGCTCTTTGACAACATGGCTAAGATGCAGTTCCAGTTAGATGCCAGTCAGAACCCAACCAAGACGAGCCTTGGCATGTACAGCAAAGAGGAGGAATATGTGGCCTTCAGTGAGGCCTGTGACTGCAGTGGGCAGGTTGAAATATGGCTGAACCGTGTTCTTCGTCACATGAAAGCCACTGTGAGGCATGAGATGACAGAGGGGGTCACTGCCTATGAGGAAAAGCCCAGGGATCAGTGGCTGTTTGATTACCCGGCTCAGGTGGCTCTGACCTGCACTCAGATCTGGTGGACGACAGAGGTGGGCATTGCATTTGCCAGGCTGGAGGAAGGCTATGAGAGTGCCATGAAGGACTACTATAAGAAGCAAGTGGCCCAACTCAAAACCCTTATCACCATGCTAATTGGGCCGCTCTCCAAGGGGGACAGGCAAAAGATCATGACCATATGCACCATCGATGTGCATGCCCGGGATGTGGTAGCCAAGATGATTGCTCAAAAGGTTGACAATGCCCAGGCTTTCCTCTGGCTGTCACAGCTACGACATCGTTGGGATGATGAGGCCAAGCACTGCTTTGCTAACATCTGTGACGCCCAGTTTCTATATTCCTATGAGTACTTGGGAAATACACCTCGCCTAGTGATCACGCCTCTGACT------GATAGGTGCTACATCACTCTCACCCAGTCTCTACACTTGACCATGAGTGGGGCTCCAGCAGGACCTGCAGGCACAGGCAAGACAGAGACCACCAAGGACCTGGGCAGAGCACTCGGCATCATGGTCTATGTGTTTAACTGTTCTGAGCAGATGGACTACAAGTCCTGTGGCAACATCTACAAAGGCCTGGCTCAGACTGGTGCCTGGGGCTGTTTTGATGAGTTTAACCGAATCTCTGTGGAGGTCTTGTCGGTGGTGGCTGTCCAGGTAAAAAGCATCCAGGATGCAATCAGAGACAAGAAGCAGAGGTTCAGCTTCCTTGGAGAGGAGATTAGCCTTGACCCTTCAGTGGGCATCTTCATTACCATGAACCCAGGCTATGCTGGCCGCACAGAACTGCCAGAGAACCTCAAGGCCCTTTTCAGGCCCTGTGCAATGGTAGTTCCAGACTTTGAGCTGATCTCTGAGATTATGCTGGTAGCAGAAGGATTCATTGAAGCCCGGTTGTTGGCCAGGAAGTTCATTACCCTTTACCGGCTGTGTAAAGAACTTCTCTCCAAACAGGATCACTATGACTGGGGACTTCGTGCCATTAAGTCTGTCCTCGTGGTAGCAGGATCACTGAAACGGGGAGACCCTGACCGCCCAGAGGACCAAGTCCTGATGCGTTCTTTGAGAGACTTCAACATCCCAAAGATCGTGACAGATGACATGCCGGTGTTCATGGGTCTGATAGGTGACCTCTTTCCTGCTTTGGATGTCCCCAGGAAGAGAGATCTGGACTTTGAGGCTGTGGTTCGGAAAGCAATCGTGGACCTTAAGCTCCAGGCTGAGGACAACTTTGTGCTCAAGGTGGTCCAGCTGGAGGAGCTGCTAGCTGTAAGGCACTCTGTG---TTCGTGGTGGGCGGTGCTGGT------ACCGGGAAGTCACAGGTACTGAGGTCTTTACACAAGACCTATCAG------ATCATGAGACGTCGCCCTGTGTGGACTGACCTCAACCCCAAAGCTGTCACAAATGATGAACTCTTT---------------------------------------GGCATCATCAATCCAGCCACTCGAGAATGGAAGGATGGA---CTGTTCTCTTCCATCATGAGAGAGCTTGCCATCATCTCTCATGATGGGCCCAAGTGGATCTTACTGGATGGCGATATAGACCCGATGTGGATAGAGTCTCTGAACACAGTCATGGATGATAACAAGGTACTGACCCTGGCAAGCAACGAGAGAATCCCCCTTAACCCCACAATGCGTCTTCTTTTCGAGATCAGCCACCTGCGCACAGCCACACCAGCAACCGTCTCCAGAGCAGGGATCCTGTACATAAACCCTGCAGACCTGGGATGGAACCCTCCAGTAAGCAGCTGGATTGATCAGAGAGAAGTCCAGACTGAGAGAGCCAACTTGACCATCCTGTTTGACAAATATCTTCCTACCTGCTTGGACACCCTCAGAACCAGATTTAAGAAAATAATTCCAGTCCCAGAGCAGAGTATGATCCAGATGCTGTGCTACCTCCTTGAGTGCCTCCTGACAAAGGAGGATATCCCTGCAGACTGCCCCAAGGAAATATATGAACTCTATTTTGTGTTTGCTGCCATCTGGGCATTTGGCAGTGCTGTGATCCAAGATCAGCTTGTAGACTACCGGGCAGAGTTCAGCAAATGGTGGCTGACTGAGTTTAAAACAGTCAAGTTTCCTTCCCAAGGAACTGTCTTTGACTACTACATAGACCCAGAGACCAAGAAATTTGAGCCCTGGGCCAAGCTCATCCCCCAGTTTGAATTTGACCCAGAGATGCCTTTGCAGGCTTGTTTGGTACACACAAGTGAGACCATCCGGGTGTGCTACTTCATGGAGCGGCTCATGCAATGGAGGCGGCCGGTTATGCTGGTTGGCCCTGCAGGCTCAGGCAAGTCTGTGCTGGTGGGAGCAAAGCTGTCCAGCCTTAACCCTGAGGAATACATGGTGAAAAATGTGCCCTTCAACTACTATACTACGTCAGCAATGCTGCAAGCTGTCTTGGAGAAACCTCTAGAAAAGAAAGCTGGCAGGAATTATGGCCCTCCAGGCAACAGGAAACTCATCTATTTCATCGATGACATGAATATGCCCGAGGTGGATGCCTATGGCACAGTACAGCCCCACACTGTCATCAGGCAGCACCTAGACTATGGCCACTGGTATGATCGGAACAAGCTGTCTCTGAAGGAGATCATGAATGTACAATACATCTCCTGTATGAACCCCACTGCAGGCAGCTTTACCATCAACCCAAGGCTTCAGCGCCACTTCAGCGTGTTTGCCCTCTGCTTCCCAGGAGCTGATGCCCTCTCTTCCATCTATAGCACCATCTTGACCCATCATCTGAAGTTTGGAAACTTTCCCACCACCCTGCAGAAATCCATCCCTCCTCTGATAAACCTGGCTGTCACCTTCCATCAGAAAATTGCCACCACGTTTCTGCCCACAGCAATCAAATTTCACTACATCTTCAATCTCAGAGATTTTGCCAATATTTTCCAAGGCATTCTTTTCTCCTCCGTGGAATGTGTAAAGTCCACACAGGACCTAGTGAAACTCTATCTGCACGAGTCAAGTCGGGTTTATCGGGATAAGATGGTGGAAGAAAAGGATTTCAATCTTTTTGACAAAATCCAAACAGAATTCCTCAAGAAAAATTTTGATGATAGTGAAGAGGTGCTGAAGCAGACCCAGAACCTGAACATGTATTGTCACTTTGCAAATGGCATTGGTGAGCCCAAGTACATGCCTGTGCAATCATGGGACCTTCTGAATCAGACTCTGGTGGAAGCCCTGGAGAGCCACAATGAAGTGAATGCTGTGATGGACCTAGTTCTCTTTGAGGATGCCATACGTCACATCTGTCACATCAACCGAATCCTGGAGTCCCCTCGAGGAAATGCCCTGCTAGTTGGTGTAGGTGGGAGTGGTAAGCAGAGTCTGACAAAGCTGGCAGCTTTTATCAGTTCCATGGATGTATTCCAGATCACCCTTCGCAAAGGCTACCAAATCCCTGACTTCAAGGTGGACCTGGCCAGCCTCTGTCTGAAAGCTGGGGTAAAAAATCTCAGTACAGTGTTCCTTATGACTGATGCCCATGTGGCTGACGAGAGGTTCCTGGTGCTCATCAATGACCTCCTGGCATCTGGTGAGATCCCAGATCTCTACTCTGATGAGGAAGAGGAGAACATCATAAACAATGTGAGAAATGAGGTCAAAAGCCAGGGACTCATGGACAGCAGGGAGAACTGCTGGAAATTCTTCATAGAGAGAGTCCAGCGACAACTTAAGGTGACTCTCTGTTTCTCCCCTGTGGGGAACAAGCTGAGAATTCGAAGCAGGAAGTTCCCAGCCATTGTGAACTGTACTGCTATCAACTGGTTCCATGAGTGGCCTCAGGAGGCCCTAGAGTCTGTGAGCCTCCGATTCTTGCAGAATACAAAGAACATTGAGCCTGCGGTGAAGCAGTCAATTAGCAAGTTCATGGCCTTTGTCCACATAAGTGTCAACAAGACATCCCAGTCATACCTGACCAATGAGCAGCGATACAACTACACAACACCCAAGTCCTTTCTGGAGTTCATCAGACTGTACCAGAGCTTGCTGGAGAGAAATGGAAAAGAGCTCCAGGCCAAGGTGGAGAGGCTGGAGAACGGGCTGTTGAAACTGCACAGCACCTCGGCCCAGGTGGATGATCTGAAAGCGAAGCTTGCCACCCAGGAAGTGGAGCTGAGGCACAAGAATGAAGATACAGACAAGCTGATTCAGGTGGTGGGTGTGGAGACCAGCAAAGTGAGCAGAGAGAAAGCCATTGCTGACGAGGAGGAGCAGAAGGTGGCCCTGATCATGCTGGAGGTGCAGCAGAAACAGAAAGACTGTGAAGAGGACCTGGCTAAGGCCGAGCCAGCCCTGACCGCAGCGCAGGCGGCCCTCAACACTCTCAACAAGACCAACCTGACAGAGCTGAAGTCATTTGGTTCCCCACCTCTGGCTGTCAGCAATGTCAGCGCCGCGGTGATGGTTCTCATGGCCCCAGGGGGCAAGGTGCCCAAGGACCGCAGCTGGAAGGCTGCCAAAATCACCATGGCCAAGGTGGACAGCTTCCTGGATTCCCTAATCCACTTCGACAAGGAGAACATTCATGAGAATTGCCTCAAAGCCATCAGGCCATACCTGCAAGATCCTGCATTCAACCCAGAGTTTGTGGCCACCAAGTCCTATGCAGCTGCAGGCCTCTGCTCTTGGGTAATCAATATTGTGAGGTTCTATGAGGTCTTCTGTGATGTGGAACCAAAGCGCCAGGCTTTGAACAAAGCCACCTCAGACCTCACAACTGCCCAAGAGAAGCTGGCAGCCATCAAAGCCAAGATCACACACCTTAATGAAAACCTGGCGAAGCTCACCACCAAGTTTGAGAAAGCAACAGCAGAGAAGCTCAAGTGTCAGCAAGAAGCTGAACTGACCGCAGGCACCATTTCGCTTGCAAACCGTCTGGTTGGAGGCCTTGCATCTGAGAACATAAGGTGGGCAGAGGCTGTGCAGAACTTCAGACAGCAGGAAAGGACGTTATGTGGCGACATTCTGCTTACTACAGCTTTCATCTCCTACTTGGGCTTCTTTACCAAAAAGTACCGAAAGAGCCTCATGGATGGGACCTGGAGACCCTATCTGAGCCAACTGAAAGTTCCCATTCCAACCACCCCAACTCTGGACCCCCTGAGGATGCTAACCGATGATGCTGAAGTGGCTGCCTGGCAGAATGAGGGTCTCCCTGCTGACCGCATGTCCATGGAGAATGCTACCATCCTCATCAACTGTGAGCGCTGGCCTCTCATGGTCGACCCTCAACTGCAAGGCATTAAATGGATCAAGAACAAATATGGAGAAGAACTCCGGGTCACCCAGATTGGCCAAAAGGGCTGCCTTCAAACCATAGAGCGAGCCCTGGAAGCTGGAGATGTGGTACTGATTGAGAACCTTGAGGAGTCCATTGATCCCGTCCTGGGACCTCTGCTTGGGAGAGAAGTCATTAAGAAAGGACGGTTTATCAAGATTGGAGACAAGGAGTGTGAATTCAATCCCAAGTTCCGGCTCATCCTTCATACCAAGCTGGCCAACCCTCACTACCAGCCTGAGCTGCAGGCTCAGGCTACCCTGATCAACTTCACGGTGACCAGGGATGGCCTGGAGGACCAGCTGCTGGCTGCTGTGGTCAGCATGGAGAGACCAGACCTGGAACAGCTGAAGTCCGATCTCACAAAGCAGCAGAACGGGTTCAAAATCACCCTCAAAACCTTAGAGGACAACCTGCTATCTCGCCTCTCTTCAGCCTCGGGGAACTTCCTGGGAGAAACAGCCTTGGTGGAGAACCTGGAGGTCACCAAGCAGACTGCTGCAGATGTGGAGGAAAAGGTCCAAGAAGCCAAATTGACAGAAGTAAAAATTAATGAGGCCCGAGAGCACTATAGGCCAGCAGCTGCCCGGGCATCTCTGCTCTACTTCATCATGAATGACCTCAGCAAGATCCATCCAATGTATCAGTTCTCCCTCAAGGCCTTCAGCATTGTCTTCCAGAAAGCTGTGGAG------AAGGCAGCTCCCAGTGAAAGTGTCACAGAGCGAGTGACTAATCTAATAGACAGCATAACTTTCTCAGTGTACCAGTATACCACACGTGGCCTCTTTGAGTGTGATAAGCTGACCTACCTAGCCCAGCTCACCTTTCAGATTCTCCTCGTGAACCAGGAAGTTAATGCAGCAGAGTTGGATTTCTTGCTTAGGGCTCCAGTACAGACAGGGACTCCCAGCCCAATGGAGTTCCTGTCCCACCAGGCCTGGGGAGGCATCAAGGCACTCTCATCAATGGAGGAATTCTGCAATCTGGACCGAGACATTGAAGGCTCTGCCAAGAGCTGGAAAAAGTTTGTGGAGTCAGAGTGTCCCGAGAAGGAGAAGTTTCCCCAGGAGTGGAAGAACAAGACAGCCCTGCAGCGCCTCTGCATGATGAGAGCCATGAGGCCTGACCGGATGACCTATGCCATGCGAGATTTTGTTGAGGAGAAGTTGGGAAGCAAATACGTGATGGGAAGAGCACTCGATTTTGTAACCTCATTTGAAGAGTCAGGACCAGCCACTCCCATGTTTTTCATCCTGTCTCCAGGGGTGGATCCACTGAAGGATGTGGAAAATCAAGGAAAGAAACTTGGATATACATTCAACAATCGGAACTTCCACAACGTGTCCCTAGGGCAAGGACAAGAGGTAGTTGCTGAGGCTGCACTGGACTTGGCTGCTAAGAAGGGTCACTGGGTGATTCTGCAGAACATCCACCTGGTGGCCAAGTGGCTCAGTACCCTGGAGAAGAAACTGGAGGAGCTCAGCGAGGAAAGTCACCCAGACTTCAGGGTCTTCATCAGCGCAGAGCCTGCACCCTCCCCTGAGGGCCACATCATTCCCCAGGGCATTCTGGAAAACTCCATTAAGATCACCAATGAGCCTCCCACAGGCATGCACGCCAACTTACACAAAGCCCTGGACAACTTCACTCAGGACACTCTGGAGATGTGTTCCCGGGAGACAGAGTTCAAGACCATCCTCTTTGCTTTGTGCTACTTTCATGCGGTGGTTGCCGAGAGACGGAAGTTTGGGCCACAGGGCTGGAATCGGTCCTATCCATTTAACACTGGGGACCTCACCATCTCTGTGAATGTGCTATATAATTTCCTGGAGGCTAACACAAAGGTACCCTATGACGACTTGCGTTACCTGTTCGGTGAGATCATGTACGGTGGCCATATCACAGATGACTGGGACAGGAGACTCTGCAGAACCTATTTAGAGGAATTCATTCGGCCAGAGATGCTAGAAGGAGAGCTCTCCCTGGCCCCGGGGTTCCCACTCCCAGGAAACATGGACTACAGTGGCTATCACCAGTATATTGATGCTGAGCTGCCCCCTGAGTCTCCCTACCTATATGGCCTCCATCCAAACGCCGAGATTGGCTTCCTGACCCAGACATCGGAAAAACTCTTCCGAACCGTGCTGGAGATGCAGCCTCGGGACAGCCAGGCTGGAGATGGAGCTGGCATCACAAGGGAAGAAAAGGTCAAAACCTTTCTGGAAGAAATACTGGATCGGATGACAGATGAATTTAACATCGCGGAGCTAATGGCTAAGGTGGAGGAACGCACCCCCTACATTGTAGTTGCCCTCCAGGAGTGTGAACGCATGAACATCCTTACCAGAGAGATCCAGCGCTCACTAAGAGAGCTGCATCTTGGCTTACAGGGGGAGCTGACCATGACCAGTGAGATGGAAAACCTACAGAATGCCCTATATCTAGATGTGGTCCCAGAGTCCTGGGCCAGGCGAGCCTACCCTTCCACAGCAGGCCTGGCAGCCTGGTTTCTAGACCTGCTTAACAGAATCAAAGAGCTGGAGTCCTGGACAGGCGACTTCTTGATGCCCTCAACTGTGTGGCTGACGGGCTTCTTCAACCCCCAGTCCTTCCTGACTGCCATCATGCAGTCCATGGCCCGCAAGAATGAATGGCCACTAGACCAGATGGCCCTGCAGTGTGATGTGACAAAGAAGAACAGAGAGGAGTTCCGGAGCCCTCCTCGGGAAGGGGCCTACATCTATGGGCTCTTCATGGAAGGTGCCTGCTGGGACACACAGACTGGGATCATTGCAGAGGCGAAACTGAAGGACCTGACACCCCCCATGCCTGTGATGTTCCTCAAGGCCATTCCAGCAGATAAGCAAGATTGTCGAAGTGTCTATGCTTGTCCTGTGTACAAGACTTGTCAGCGGGGACCCACCTACGTGTGGACTTTCAATCTGAAGACTAAAGAAAACCCATCCAAGTGGGTTCTGGCTGGTGTTGCCTTGCTTCTCCAGATT",
+    "Opossum": "ATGCCAGTGAAAGTG------GCGGCGGTGTTCTCCGAGGCTGAGGATGGAGATAGCGAGAAAGGG---CCAGATCCTAGAATACGGCTCCTGGGCACCTACGTGATTCGGTGCTTGCGGCCAGCGGCTGGCGCCTGGAAGCGCTGTGTGAGCACGGCCGAATCTGAGCAGCTGCTCCAGGCCTTCCTGACAGGCTACTGCCCTCAAGAG---------CCG------ATGTTGGTGGTGCGTCCTGGGGGTGGGGGTCTGCAGCTGAGCTCCGGG------------CCATACCCCGATTTGTCTCGAGCCAAAGCGCTGTTCTTCCTGCGC---GGTTCCCCCAATCCCCCAGGACCCTTGGGTCCCAAAGGCGCAGTGCTCTGCGGGGAGCTGGCCCCGGCACCGTTGGAGCATCTGGCCACGCTGGTGGCTGAGGTAGTGATGCCTGTCCTGACCAATGAAAAGAATCACCAAGACTGGCCAAATGCTTTATATCAGGATGTAAGACGACACATCCACCACCTTCAAAGTGACCTCATTATCTTCCTGGGTCAAGTGACAGGAAAAACATTGCTGCCTCTTCCAGTAGGCTCAGAAAACATGGAATGTGCGGATTATGAAAATGAAAAAGACTTGGATTTCACAGATAAATCAATTGTCTATGCTATTGAGTCCACAGTGATCAAATGGAGCCACCAGATTCAAATAGTATTAAAGAGGGAATCTTCAGAACCACTCTTGCAGGGAGGAAATCCCACCCCAAAAGTGGAGCTGGAATTCTGGAAGAGAAGGTGTGAAGATCTGGAATATATTTATAATCAGCTGAGAGCCATAGAAGTGAGGGGCATAGCTGCACTTTTAAACAGACTTCAGAGCAGCTACTTCCCAGCCTTCAAAACCATGTTCAAAGATGTAATAGCAGCTTTAAGAGAGGCCCAGGATATCTATGTACATCTGAAGCCCCTGCAACGCCATGTGGAAAACATAGAGAATGTGGAATTTAGTGAAGTGAAGCCACTGGTGGGACCCCTGCTTCACGTAATCTTCTTGATTTGGTCCACATCTAAATACTACTGCTGTCCAGTACGGATCATTGTGCTACTGCAGGAAATATATAACCTTCTCATTCAGCAGGCCTGTACATATCTTAGCCCAGAAGATCTACTGAAAGGGGAGATAGAAGAGAGTCAGAGGAAAATACAGGTGGTGATGGACATTCTTAACTTTTCCAAAGAGATGTTTGAGAATAGGAGGAACAATCTCAAGACTTACTTCAAACAGGTCCGGGAGGTGAAGGAATGGGATTTCAATTCTTCTATGATCTTTGTGCGACTAAATAACTTCCTCAAAAGACTCAAGATGGTAGAGAATCTTCTGAAGACAACCTTGGATTTTCTCAAGCTAGAGAAACTTGAATTCAGTGGAATTAGAGGGAATGCTTTGAGTCAACAAGTCCAGGGCATGTATGAAGAATTCCAGAATGTGTACAAAGCCTTTTCAGAATGCTTCTATGACTGTCTGGACCCTAAACACACAGAATTCGAAAATTATGTTGCTGAATTCAACCACAAAGTAGAAGATTTGGACCGAAGATTAGGGATGGTCTTCCTCCAAGCTTTTAATGATGTATCTGGCTTAGAGCATGCTTTTAAGTTGCTTGAAATATTTGGGAGTCTGCTTGAAAGACCAGTAGTAGCCATGGATGTATTTGATAAATACCCAAGACTGATCACAATGTTCAGCAGTGACTTGGATGCTGTTAAGACAATCTATTGTCAGCATGTCCAGGAGGAGTCAGAACTTGGGTTTTCCCAATTACACAAGAACATGCCGGCAGTAGCTGGGGGTCTCCGCTGGGCTCAGGAACTCAGAGAACGAATTGAAATTTCATTCAATAACCTAAGACATATCAATCACCCCTATATGGAGTCCACTGAAAGTAAAGAGATGTTCCAAAAGTATGGTGAAATGTTTACATTGTTAGAAAAGTATGAGACAAAACTTTATGATAGCTGGTGCCAGACAGTGTCAGAGAAGTCACAATACAATCTCACTCAGCCACTCCTCTGTCATGATCCAGAAACTAAGCAGATCATTGTCAACTTTAACCCACAG---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------GAAAAC---ATGAAA------------------------------------------------------------------------------------------------------------------------------------------------------CTCTTCCTTGCAGATCCAGCATCCAGTATGTGGAAGGCATACATTGACTACCTTGATAACATGGTTCTTCATGGATTCTTCATTGCTATTGAATCTTCTCTAAATTATCTCCTGGAAAATACTGATTCTAAGAACAGACTTCCTCCCTTTTTTGAAACACAATTGGATCTAGTTATACCAGAACTGATCTTTTGTCCCTCTCTGGACCCTTTTGCTAATGGTGGTTTTCAAAGCATTGTGGAGGGACTTATCAATGACATTTTCAAAATATCTTCTATGGTCCCACGACTT---GCACAGAAAAGTTCCCCTCATTATCAGGCTGACATGGAGGACACAGAAGATCTGTCAAACCTGAGGAATATATTAATGGAGAGAGTCAAGAATATGATGACCATCTGCTGTGACTATCGGAACTCCTTTGACCATTACTCTTTCCTTTACATGGATGACCGAAAGGAATTTATGCGACAATTTCTTTTATATGGACATATGCTCACACCAGAGGATTTAGAAGCCCATGGAGAAGATGAGATCCCTGAAAATCCTCCCACTCTTCAGCAATTTAAATTGCAGATTGATTCCTATGAAAAGATTTATGAAGAGGTGAACCAGCTAGAGCCTTTCAGAATTTTTGACAACTGGATGAAAATTGATATTCGTCCATTTAAGATGACTCTACTAAATGTAATTAAGAGATGGAGCTTCATGCTTAAACAGTATCTCATTGATCATGTCACTCACAGTTTGGCAGACCTTGAAGTCTTTATAAGAAATGGTGAGAGTGGTTTAAACAAGAAGATAGAAAAAGGTGATTTTGCTGGTTTGGTTGAAATTATGAGAACTCTAATGGCTCTTAAAGAACGACAGAGCAGCACTGATGAGATGTTTGAGCCACTGAAACACACAATTGATTTACTGAAGATCTATGAACAAGAATTACCTGATTCAGTATTTAAACAGCTAGAGGAATTGCCAGAAAAATGGAGCAACATAAAGAAGATGGCAGTCATTGTAAAACAGCATGTAGCTCCCCTGCAGGAAGATGAAGTAACAGCTCTCCGTCAAAAATGTGCCATTTTTGCTATTGAACAGAATATATTCCAAGATCAGTTCCACAAAGAAGCTCCTTTCAGGTATGATAGCATTAAGCCTCACCAAGTCTTGGATGCCAAAAACATTCAAATCCAACAGATGGAATCTTTCATGTCCTCCATTTCAGACTCTACAAATTTGTTTGAAGTCAACATTCCTGATTACAAACATTTAAAACAATGCAGGAAGGAGATCTGCTTGTTGAAGGAGCTTTGGGATATGATTGACCTAGTGAATTTTAGCATCAATAACTGGAAGGTAACCAAATGGAGGAATATTAATGTAGAGAATATGGACTTAGAATGTAAAAGTTTTGCCAAACAAATATGGAAACTTGGCAAGGATGTGAGAGCCTGGGATGCTTTCATGGGGCTGGACAACACTCTGAAGAACATCCTAACATCCTTACGGGCTGTGTCTGAACTTCAAAATCCAGCCATAAGAGAGAGGCACTGGAACCAGCTGATGCAGGCTACAGGTATGAAATTCATCATGAATGATGATACCACCCTTGAAGACTTACTTAAGCTTGAGCTACACAACTTTGAAGAGGCGATCCAGGGCATTGTAGACAAAGCTGTGAAAGAGATGGACATGGAAAAAGTTCTAAAGGAACTAAAAGCCACTTGGGCAGGGATGGAATTTCATTATGAGCCCCACCCCCGGACAATGGTCCCACTGATGAGGTCTGATGAAGACCTTATTGAAACTCTTGAAGATAACCAAGTCCAGCTGCAGAATCTAATGACATCCAAGTACATAGCCTTCTTCCTGGAGGAAGTATCTGACTGGCAGAAGAAGCTCTCAATAGCTGATGCTGTCATTTCAATCTGGTTTGAAGTACAGCGTACATGGTCTCATCTTGAAAGCATTTTCATTGGATCTGAAGATATACGAGCACAGCTTCCTAAGGACTCTAAACATTTTGAAGACATTGATACTGATTTTAAAGAGTTAGTTTGTGATGCTCAGAAGACACCAAATGTGGTAGAAGCTACCAACAAACCAGGTGTTCATGAACAATTAGAAGATATTCAGAACAGGTTGAGCCAGTGTGAGAAAGCCTTGACTGAATATCTAGATACCAAGAGACTGGTCTTCCCCAGGTTTTATTTCCTCTCCTCTTCCGACCTTTTAGACATCCTTTCCAACGGCACAAATCCACAACAAGTTCAACGCCATCTTTCTAAGTTATTTGACAGTATGGCTAGGATGAAGTTCCAGGTGGACTCCAGTCAAAAACCAACCAAGAAAAGCCTCGGCATGTATAGCAAAGAGGAAGAGTATGTGAATTTCAGTGAGCCTTGTGACTGTAGTGGCCAGGTTGAACTCTGGTTGAATAATGTGCTCAATCACATGAGGGCCACCGTGAGACATGAAATGACAGAAGGTGTCACTGCCTATGAAGAGAAACCTAGGGAACAGTGGCTCTTTGACTACCCTGCTCAGGTGGCCTTGACATGTACCCAGATCTGGTGGACCACTGAGGTGGGAATTTCCTTTGCCAGGCTGGAAGAAGGATATGAAAGTGCCATGAAGGACTATTATAAGAAACAAGTTACCCAACTGAACACCCTGATCACCATGCTAATTGGCCAGCTCTCCATGGGTGACCGTCAAAAAATCATGACCATCTGTACTATTGATGTGCATGCTCGAGATGTAGTTGCCAAGATGATCTCTCAGAAGGTAGAGAACACTCAGGCTTTTCTCTGGATGTCCCAGATGCGCCATCGGTGGGATGATGAGAAAAAGCACTGCTTTGCCAATATTTGTGATGCTGAATTCCTGTATTCCTATGAGTACCTGGGTAACACACCTCGCCTGGTGATTACCCCTCTGACA------GACAGATGTTACATTACCCTCACCCAGTCTTTGCATTTGACCATGAGTGGGGCTCCAGCAGGACCTGCAGGCACTGGCAAAACTGAGACTACCAAAGACCTGGGTCGAGCATTGGGTATCATGGTATATGTGTTTAACTGTTCTGAGCAAATGGACTACAAGTCTTGTGGCAATATCTACAAAGGCCTTTCTCAGACTGGTGCCTGGGGCTGTTTTGATGAATTTAACAGAATTTCTGTGGAGGTTCTTTCCGTGGTGGCAGTACAGGTGAAAAGTATTCAAGATGCAATCAGAGATAAGAAGCTGAATTTCAATTTCCTTGGAGAGGAGATTAAATTGAATCCCTCAGTGGGAATCTTCATCACTATGAACCCAGGATATGCTGGCCGTACAGAGCTTCCAGAGAACCTTAAGGCTCTCTTCAGGCCTTGTGCTATGGTGGTACCAGATTTTGAATTGATCTGTGAAATCATGTTGGTTGCTGAAGGATTCATCGAGGCACAATCATTGGCCAAAAAATTCATTACCCTTTATCAGCTTTGCAAAGAGCTCCTCTCCAAACAGGACCATTATGACTGGGGTCTGCGAGCTATCAAGTCTGTGCTTGTGGTAGCAGGATCTCTGAAGAGAGGAGACCCTGACCGACCTGAAGACCAAGTCCTAATGCGTTCCCTCAGAGACTTCAATATTCCCAAAATCACAACTGATGACATGCCTGTGTTTATAGGCCTAATTGGAGACCTTTTCCCTGCCCTTGACATCCCCAGAAAGAGAGACCTTCACTTTGAAAGTTTTGTAAAACAGGCAATATTAGAGCTAAAACTTCAGGCTGAGGACAACTTTATGCTCAAAGTGGTACAGCTAGAAGAACTTTTGGCTGTGCGACACTCTGTG---TTTGTGGTGGGGAATGCTGGT------ACAGGAAAATCCCAGGTACTAAGATCTTTGCAAAAGACATACCAG------AACATGAAACGACGACCAGTCTGGACTGATCTCAACCCCAAAGCTGTCACTAATGATGAACTATTT---------------------------------------GGCATCATCAACCCAGCCACAAGAGAATGGAAAGATGGA---CTTTTCTCATCAATCTTGCGTGAACTTGCCAATATAATACATGATGGGCCCAAGTGGATTTTACTAGATGGCGATATTGATCCAATGTGGATTGAATCTTTGAACACTGTCATGGATGATAACAAGGTTCTGACTCTGGCAAGCAATGAAAGAATCTCTCTCAATCCAACTATGCGGCTCCTGTTTGAGATCAACCACTTGCACACAGCTACCCCTGCCACAGTCTCCAGAGCAGGAATACTATACATCAATCCTGCAGACCTGGGTTGGAATCCACCAGTGAGTAGTTGGATTGACAAGAGAGAGATACAGTCTGAACGAGCTAACCTGACCATCCTATTTGACAAATATTTGCCACCTTGCCTGGATGTAGTCAAAACAAGATTTAAAAAGATTGTTCCAATACCAGAGCAGAGCATGATTCAAATGCTGTGTTACATTCTTGAGTGTCTTCTAACAAAGGAAAACAGTCCCCCAGACTCTCCCAAGGAACTTCATGAACTTTATTTTGTGTTTGCTTCTATCTGGGCTTTTGGTGGAGTATTGATCCAAGACCAGCTTGTGGATTACAGAGCAGAGTTCAGTAAATGGTGGATAACTGAATTCAAGACAATCAAGTTTCCTTCCCAAGGAACAATCTTTGACTTTTACATAGAACCAGAAACAAAGAAATTTGAGCCGTGGTCCAAACTTATCCCCAAATTTGAATTTGACCCAGACCTACCTTTGCAGACTTGCCTGGTACACACTGTTGAGACCATTCGTGTGTGCTATTTCATGGAGCAGCTCCTGAAACACCGGAGACCTATCATGTTGGTGGGGAATGCAGGCACTGGGAAATCTGTTCTGGTAGGGGCAAAATTGGCTACCCTGGATGCAGATGAATACATGGTGAAGAATATCCCATTTAATTATTATACTACATCTGCAATGCTACAAGCTGTCCTAGAGAAACCTCTAGAAAAGAAAGCTGGAAGAAATTATGGCCCACCTGGCACCAAGAAACTCATCTATTTCATTGATGATATGAACATGCCTGAGGTAGATGCATATGGAACAGTGCAACCCCACACACTCATCAGACAGCATATGGACTATGGGCACTGGTATGACAGAAATAAACTGTTCCTCAAAGAAATCATGAATGTACAATATGTGGCCTGTATGAATCCGACAGCTGGTGGCTTCTCTATCAATCCTCGGCTACAGCGTCATTTTAGCATCTTTGTGCTCTCCTTCCCTGGAGTAGATGCATTGTATTCAATCTATAGCACCATCTTGACTCAGCATCTAAAACTTGGTAACTTTCCAGCATCACTGCTGAATTCCACCCCCCGACTCATTAACTTGGCCATTACCTTCCATCAGAAGATTGCTGCCACTTTTCTCCCCACAGCAATAAAATTCCATTATATCTTCAATCTCCGAGATTTCTCCAACATTTTCCAAGGCATTCTCTTTTCAACAGTGGAAAGTGTTAAAACCACATCAGACCTTGTGAAGCTCTATCTTCATGAGTCCAATCGGGTTTATCGCGATAAGATGGTTGAAGACAATGACTTTGACAACTTTGATAAAATCCAAATTGAAGTGGTAAATAATTTCTTTGATGATATGGACAAGACTCTAGAGGAAATCAAGAGATTGAATATGTACTGCCACTTTGCAAATGGTATTGGTGAGCCCAAATATATGCCAGTGAAGACATGGGAACTGCTTACCCAAATCCTGGTGGAAGCCTTAGAGAACCACAATGAAGTCAATCAAGTGATGAATCTGGTTCTTTTTGAGGATGCCATGTGCCATGTTTGTCGTATCAATCGCATCCTAGAATCCCCAAGGGGGAATGCTTTGCTGGTTGGAGTAGGTGGAAGTGGCAAACAGAGCCTGACAAGACTTGCAGCTTTTATCAGCTCCATGGATGTTTTCCAGATCACTCTAAGAAAAGGTTATTGTATTTCTGATCTTAAGATGGATTTAGCCAATCAGTGCCTAAAAGCTGGAGTAAAGAATGTAAGCACTGTATTTCTCATGACAGATGCCCAAGTTGCTGATGAAAAGTTCCTTGTCCTTATCAATGATCTGTTGGCATCTGGAGAGATTCCAGATCTATACTCTGATGATGAAGTTGAAAACATCATAAACAATATGAGAAATGAAGTCAAGAGCCTGGGTTTGTTTGACAGCAGGGAAACTTGCTGGAAAGTCTTCATAGAAAGGGTCCAAAAACAATTAAAGGTTATACTCTGCTTCTCCCCTGTGGGGAATAAGCTAAGAGTCCGCAGCAGGAAATTTCCAGCCATTGTGAACTGCACAGCCATTGATTGGTTTCATGAGTGGCCTCAGCAAGCACTAGAATCAGTGAGCCTGCGCTTCTTACAAAACATAGAGAATATTGATCCAGCAGTAAAAGAGTCAATTAGTAAATTCATGGCTTATGTACACACGAGTGTCAACCAAATGTCCCAGTCCTACCTGAGCAATGAACGGCGCTATAATTACACCACCCCAAAATCCTTCCTGGAACAGATCAGACTCTATCAGAACCTACTGGTCAAGAATGGCAATGAGCTGACATCTAAAATGAAGAGGCTTAAGAATGGACTGCAGAAGCTTCACAGTACATCTTCCCAGGTAGATGACCTGAAAGCTAAACTGGCACTCCAGGAAATAGAGCTCAGGCAGAAGAATGAAGATGCAGACAAACTAATTCAAGTGGTTGGAGTAGAGACAGAGAAAGTAAGCAAAGAGAAAGCCATTGCTGATGAAGAGGAACATAAAGTGGCTCTAATCATGTTGGAGGTCAAGCAGAAGCAAAAGGACTGTGAGGAAGATCTGGCCAAAGCAGAGCCATCTCTCACAGCAGCCCAAGAAGCTCTCAACACACTCAATAAGACCAACCTAACAGAGCTCAAGTCTTTTGGTTCACCACCTTTGGCTGTCAGCAATGTCACTGCTGCAGTAATGGTTCTCATGGCCCCTGGAGGGAAGGTACCCAGAGATCGAAGTTGGAAAGCTGCCAAGGCTACCATGGCCCGAGTTGATGGCTTTCTGGACGCCCTGGTCAACTTTAACAAAGAGAACATACCTGAGAGCTGCCTCAAAGCTATCCAACCATATATTCAAGATCCAGAATTTAAACCTGAGTTTGTGGCCTCTAAGTCTTTTGCAGCAGCTGGCCTCTGTTCCTGGGTCATAAATATTGTGAGGTTTTATGAGGTTTTCTGTGATGTGGAACCCAAGCGGCAAGCCCTGAGTAAAGCAAGTTTGGATCTTGCTATTGCCCAAGAAAAATTGGCAACCATTAAAATCAAGATTGCTCACCTTAATGAAAACTTGGCAAAACTTACAACCAAATTTGAGAAAGCAACTGCAGAAAAACTCAAATGTCAGCAAGAAGCTGAACTGACCACAGGTACCATCTCACTTGCAAATCGCCTGGTTGGAGGTCTTGCCTCTGAAAATGTAAGATGGGCAGAAGCTATTAAGGACTTCAGACAGCAAGAGAATACATTGTGTGGAGATATTTTACTGATTACAGCTTTCATTTCTTACCTGGGATACTTTACCAAGAAATATCGTCAAAATCTTATGGATTGTAGCTGGAGACCTTACCTGAATCAGTTAAAAGTGCCTTTTCCAGTCACCCCTACTTTAGATCCTCTAAAGATGCTTACTGATGATGTAGACATAGCCACCTGGCAAAATGAGGGTCTTCCTGCTGACCGTGTGTCCACAGAGAATGCTACAATCCTTATCAACAGTGAACGATGGCCACTTATAGTTGACCCTCAACTACAAGGAGTCAAATGGATTAAGAAGAAATATGGCAAAGACCTTCGAGTCATCCAGATTGGAGAGAAAGGATACCTTGATATCATAGAACATGCCCTAGCAGATGGTGATGTAGTGCTGATTGAAAACATAGGAGAGACAGTGGACCCTGTTCTAGGACCCTTGTTGGGAAGAGAAGTAATTAAAAAAGGAAGATTCATTAAAATTGGAGACAAGGAGTGTGAATATAATCCCAGGTTCCGCCTCATTCTTCACACCAAGCTTGCCAATCCTCACTATCAGCCTGAGCTCCAAGCCCAGGCAACGCTTATCAACTTCACTGTGACTAGAGATGGCTTAGAGGATCAGCTTCTGGCAGCAGTGGTCAACATGGAGAGGCCAGACTTAGAAGAACTGAGATCAGATCTGACAAAGCAACAGAATGCATTCAAGATCACACTGAAAACCTTGGAAGACAACTTGCTGTCTTGCCTCTCCTCCGCATCTGGGAACTTCCTGGGAGATATGGCTTTAGTAGAAAACTTAGAGATCACCAAAAAGACAGCTACAGAAATTCAGAAGAAGGTCCAGGAAGCCAAGATAACAGAAATAAAAATTAATGATGCCAGAGAGCATTACCGGCCAGTGGCAGCACGTGCGTCTTTGCTGTACTTCATCATGAATGACCTCAGTAAAATCCATCCCATGTATCAGTTTTCTCTCAAGGCTTTCAGCCTTGTCTTCCAAAAGGCTATACAGAAGACCAAGGCAGATGCTGATGAGAACCTCCAACAGAGAGTAGTCAGTTTGATTGACAACATCACCTTCTCTGTATATCAGTATACTACTAGGGGACTTTTTGAATGTGATAAGCTGACTTACATCACCCAGGTCACCTTTCAGACACTCATGATGAATCAGGAAATCAATGCTGCTGAATTGGACTTCCTTCTCCGGTACCCAGCACAGTCCAATGTTCTGAGCCCTGTGGATTTCCTTTCCAACCAATCCTGGGGAGGTATCAAGACTCTTTCATTAATGGAAGAATTTTGTAATCTGGATCGAGACATTGAAGGGTCTGCCAAACATTGGAAAAAATTTGTGGACTCAGAGTGTCCTGAAAAGGAGAAATTCCCCCAAGCATGGAAAAACAAGTCATCTCTACAAAAACTGTGTATGATGAGGGCAATGAGACCTGACCGAATGACATATGCTATGAGAGATTTTGTGGAAGAAAAGCTAGGAAGCAAATATGTGGTGGGCAGAGCATTAGATCTCTCTACCTCTTTAGAAGAATCAGGGTCTGCAACTCCCATGTTCTTCATACTGTCGCCAGGTGTTGACCCACTGAAAGATGTGGAGAAGGAAGGGAAGAAACTTGGTTATACCTTCAACAACCAGAACTTCCATAATGTGTCCTTGGGTCAAGGACAAGAGGTAGTAGCAGAGGCTGCATTGGATCTGGCTGCCAAGAATGGCCACTGGGTTATCTTACAGAACATCCATCTGGTAGCCAAATGGCTTGGATCCCTTGAGAAGAAGTTGGAACAACATAGCAAGAGCAGTCATCATGAGTTCAGAGTCTTCATGAGTGCTGAGCCTGCAGCTTCTCCTGATGGTCACATCATTCCCCAAGGCATCCTAGAAAATTCAATAAAGATCACTAATGAGCCTCCCATGGGCATGCATGCCAAACTGCACAAGGCCCTGGACAACTTCACTCAGAATACTCTGGAAATGTGTACCCGAGAAACAGAGTTTAAGAGTATTTTATTTGCACTTTGTTACTTCCACGCTGTTGTAGCAGAAAGGCACAAATTTGGACCTCAAGGCTGGAATCGCACTTACCCTTTTAACACTGGAGACCTTACCATCTCAGTGAATGTGCTCTATAACTTTCTTGAGGCCAATGCCAAGGTACCCTATGATGACTTGCGCTATCTCTTTGGTGAGATCATGTATGGAGGTCACATCACAGATAACTGGGACAGGAGGCTTTGTAGAACATACCTGGAGGAATTCATTAAGCCAGAAATGTTAGAAGGAGAAATGTTTCTGGCTCCAGGGTTCCCGATGCCAGGCAATATGGATTACAACAGTTATCACCAGTTCATTGATGACATGCTGCCAACAGAGTCACCATATTTGTATGGGCTTCACCCCAATGCTGAAATTGGCTTTCTGACCCACACCGCAGAAAAGCTCTTCCATACAGTGCTAGAAATGCAGCCTCGGGACAGCCAAGATGGAGATGGAGGAGGGATCACAAGAGAAGAAAAGGTAAAAGCCTTTCTGGATGAAATATTAGAGAAGATAACTGAAGAGTTTAACATTGCAGAGTTGATGGCTAGGGTAGAAGAACGTACCCCCTACGTTGTGGTTACCTTTCAAGAATGTGAAAGAATGAACCTCCTTATCAGAGAAATACAGCACTCGTTGAAAGAACTGGATCTGAGTCTGAAGGGTGAGCTAACAATGACCAGCAACATGGAGAGCTTACAGAGAGCTCTGTACCTAGATACTGTACCAGCGTCGTGGGCCAAGAAAGCATACCCATCAACAGCAGGCCTGGCAAGCTGGATTGTGGATCTGCTCACCCGAATTAAAGAGCTGGAAAGATGGATGGGAGACTTTGCATTACCCTCTGCTGTCTGGCTAGCAGGATTTTTTAACCCCCAATCATTCCTAACGGCCATCATGCAGTCCATGGCTCATAAGAATAAGTGGCCACTGGATAAGATAGCCCTGCAGTGTGAAGTGACTAAGAAGAATCGGGAAGATTTCAGTAGCCCACCTCGGGAAGGGGCCTATATCTATGGTCTGTTCATGGAAGGGGCCTGTTGGGATACACAGGCTGGAAATATCACAGAGGCTAGACTGAAGGATCTGACTCCACTCATGCCTGTGATATTCATCAAAGCTGTCCCTGTGGACAAGCAAGACAATCGAAATATCTATCCTTGTCCAGTATACAAGACTTGTCAGCGGGGACCCACTTATATTTGGACATTTGGTCTGAAAACTAAAGAAGCTCCATCCAAATGGGTATTAGCTGGTGTGGCCTTGCTTTTGCAGATT",
+}
 
 
 class MakeCachedObjects:
diff --git a/tests/test_evolve/test_parameter_controller.py b/tests/test_evolve/test_parameter_controller.py
index e968cf7a3..fcb284f12 100644
--- a/tests/test_evolve/test_parameter_controller.py
+++ b/tests/test_evolve/test_parameter_controller.py
@@ -38,7 +38,8 @@ class test_parameter_controller(TestCase):
         # length all edges 1 except c=2.  b&d transitions all other
         # transverions
         self.al = make_aligned_seqs(
-            data={"a": "tata", "b": "tgtc", "c": "gcga", "d": "gaac", "e": "gagc"}
+            data={"a": "tata", "b": "tgtc", "c": "gcga", "d": "gaac", "e": "gagc"},
+            moltype="dna",
         )
         self.tree = make_tree(treestring="((a,b),(c,d),e);")
         self.model = cogent3.evolve.substitution_model.TimeReversibleNucleotide(
@@ -165,7 +166,7 @@ class test_parameter_controller(TestCase):
         self.assertEqual(lf.get_param_value("length", "d"), 5)
 
     def test_pairwise_clock(self):
-        al = make_aligned_seqs(data={"a": "agct", "b": "ggct"})
+        al = make_aligned_seqs(data={"a": "agct", "b": "ggct"}, moltype="dna")
         tree = make_tree(treestring="(a,b);")
         model = cogent3.evolve.substitution_model.TimeReversibleDinucleotide(
             equal_motif_probs=True, model_gaps=True, mprob_model="tuple"