Upload tokenizer

special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

tokenizer.py

@@ -0,0 +1,450 @@
+import collections
+import os
+import json
+from copy import deepcopy
+from typing import List, Optional, Tuple, Dict, Set
+from transformers import PreTrainedTokenizer
+from transformers.utils import logging
+from itertools import product
+logger = logging.get_logger(__name__)
+
+
+
+#from .config_utils import SeqConfig
+#from .sequtils import generate_kmers, lca_kmer_tokenize_segment
+
+# Define the names of the vocabulary files
+VOCAB_FILES_NAMES = {"vocab_file": "vocab.txt"}
+
+# Define the mapping for pretrained vocabulary files
+PRETRAINED_VOCAB_FILES_MAP = {
+    "vocab_file": {
+        "lca-mini-k6s1": "lca-base-dna6/vocab.txt",
+        "lca-mini-k6s2": "lca-base-dna6/vocab.txt",
+        "lca-mini-k1s1": "lca-base-dna1/vocab.txt",
+    }
+}
+
+# Define positional embedding sizes for pretrained models
+PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {
+    "lca-mini-k6s1": 1024,
+    "lca-mini-k1s1": 1024,
+    "lca-mini-k6s2": 2048,
+}
+
+# Define initial configuration for pretrained models
+PRETRAINED_INIT_CONFIGURATION = {
+    "lca-mini-k6s1": {"do_upper_case": True},
+    "lca-mini-k1s1": {"do_upper_case": True},
+    "lca-mini-k6s2": {"do_upper_case": True},
+}
+
+def generate_kmers(abc: Set[str], k: int) -> List[str]:
+    """
+    Generates all possible k-mers from a given alphabet.
+
+    :param abc: The alphabet.
+    :type abc: Set[str]
+    :param k: Length of the k-mers.
+    :type k: int
+    :return: List of all possible k-mers.
+    :rtype: List[str]
+    """
+    return [''.join(p) for p in product(abc, repeat=k)]
+
+
+# Utility function to load vocabulary from a file
+def load_vocab(vocab_file):
+    """Loads a vocabulary file into a dictionary."""
+    vocab = collections.OrderedDict()
+    with open(vocab_file, "r", encoding="utf-8") as reader:
+        tokens = reader.readlines()
+    for index, token in enumerate(tokens):
+        vocab[token.rstrip("\n")] = index
+    return vocab
+
+
+def resolve_vocab_file(vocab_file: Optional[str], kmer) -> str:
+    """
+    Resolves the path to the vocabulary file. If not provided, tries to load it
+    from the installed prokbert package or download it from the GitHub repository.
+
+    Args:
+        vocab_file (str, optional): Path to the vocabulary file.
+
+    Returns:
+        str: Path to the resolved vocabulary file.
+
+    Raises:
+        FileNotFoundError: If the vocabulary file cannot be resolved.
+    """
+    if vocab_file and os.path.exists(vocab_file):
+        return vocab_file
+
+    # Attempt 1: Check if prokbert is installed
+    try:
+        import prokbert
+        package_dir = os.path.dirname(prokbert.__file__)
+        vocab_path = os.path.join(package_dir, 'data/prokbert_vocabs/', f'prokbert-base-dna{kmer}', 'vocab.txt')
+
+        print(vocab_path)
+        #vocabfile_path = join(self.current_path, 'data/prokbert_vocabs/', f'prokbert-base-dna{act_kmer}', 'vocab.txt')
+
+
+        if os.path.exists(vocab_path):
+            logger.info(f"Loaded vocab file from installed prokbert package: {vocab_path}")
+            return vocab_path
+    except ImportError:
+        logger.info("Prokbert package not installed, proceeding to download vocab.txt.")
+
+    # Attempt 2: Download from GitHub repository
+    github_url = "https://raw.githubusercontent.com/username/prokbert/main/vocab.txt"
+    temp_vocab_path = os.path.join(os.getcwd(), "vocab.txt")
+    try:
+        import requests
+
+        response = requests.get(github_url, timeout=10)
+        response.raise_for_status()  # Raise an error for HTTP failures
+        with open(temp_vocab_path, "w", encoding="utf-8") as f:
+            f.write(response.text)
+        logger.info(f"Downloaded vocab.txt from GitHub to: {temp_vocab_path}")
+        return temp_vocab_path
+    except requests.RequestException as e:
+        raise FileNotFoundError(
+            "Could not find or download vocab.txt. Ensure prokbert is installed or "
+            "provide a valid vocab file path. Error: {e}"
+        ) from e
+    
+
+class LCATokenizer(PreTrainedTokenizer):
+    """
+    Custom tokenizer for LCA (Local Context Aware) tasks.
+    Handles specific tokenization processes, including k-mer tokenization with configurable shifts.
+
+    Attributes:
+        vocab_files_names (dict): Mapping of vocabulary file names.
+        pretrained_vocab_files_map (dict): Mapping of pretrained vocabulary files.
+        pretrained_init_configuration (dict): Initial configuration for pretrained models.
+        max_model_input_sizes (dict): Maximum input sizes for pretrained models.
+    """
+
+    vocab_files_names = VOCAB_FILES_NAMES
+    pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP
+    pretrained_init_configuration = PRETRAINED_INIT_CONFIGURATION
+    max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
+    
+    nucleotide_abc = {"A", "T", "C", "G"}
+    extended_nucleotide_abc = {"A", "T", "C", "G", "*"}
+    sequence_unk_token = 'N'
+
+    default_unk_token = "[UNK]"
+    default_sep_token = "[SEP]"
+    default_pad_token = "[PAD]"
+    default_cls_token = "[CLS]"
+    default_mask_token = "[MASK]"
+
+    vocab_files_names = {"vocab_file": "vocab.txt"}
+
+
+    
+    def __init__(
+        self,
+        vocab_file: Optional[str] = None,
+        kmer: int = 6,
+        shift: int = 1,
+        operation_space: str = "kmer",
+        **kwargs,
+    ):
+        """
+        Initializes the LCATokenizer.
+
+        Args:
+            vocab_file (str): Path to the vocabulary file.
+            kmer (int): K-mer size for tokenization.
+            shift (int): Shift size for tokenization.
+            operation_space (str): Defines operation mode ('kmer' or 'sequence').
+            kwargs: Additional arguments for PreTrainedTokenizer.
+        """
+        # Load vocabulary directly from the vocab file
+        self.config = {}
+        resolved_vocab_file = resolve_vocab_file(vocab_file, kmer)
+        self.vocab = load_vocab(resolved_vocab_file)
+        #self.vocab = load_vocab(vocab_file)
+        self.id2token = {v: k for k, v in self.vocab.items()}
+        self.kmer = kmer
+        self.shift = shift
+        self.operation_space = operation_space
+
+        self.config["kmer"] = kmer
+        self.config["shift"] = shift
+        self.config["operation_space"] = operation_space
+
+        # Special tokens
+        kwargs.setdefault("cls_token", "[CLS]")
+        kwargs.setdefault("sep_token", "[SEP]")
+        kwargs.setdefault("pad_token", "[PAD]")
+        kwargs.setdefault("unk_token", "[UNK]")
+        kwargs.setdefault("mask_token", "[MASK]")
+        self.special_tokens = [kwargs["cls_token"], kwargs["sep_token"], kwargs["pad_token"], kwargs["unk_token"], kwargs["mask_token"]]
+        super().__init__(**kwargs)
+        if self.operation_space == 'sequence':
+            token_extension = sorted(list(set(generate_kmers(LCATokenizer.extended_nucleotide_abc, self.config['kmer'])) - \
+                 set(generate_kmers(LCATokenizer.nucleotide_abc, self.config['kmer'])) ))
+            self.extended_vocab = deepcopy(self.vocab)
+            for token in token_extension:
+                self.extended_vocab[token] = 4
+                            
+            self.unk_token = LCATokenizer.sequence_unk_token * self.config['shift']
+            self.mask_token = '*'
+            self.extended_vocab[self.mask_token] = self.vocab['[MASK]']
+
+            full_unk = 'N' * self.config['kmer']
+            self.vocab[full_unk] = 1
+            self.id2token[1] = full_unk
+            self.full_unk_token = full_unk
+
+        else:
+            self.extended_vocab = self.vocab 
+            self.unk_token = '[UNK]'
+
+        self.unkown_tokenid = self.vocab['[UNK]']
+        self.sep_token = '[SEP]'
+        self.cls_token = '[CLS]'
+        self.pad_token = '[PAD]'
+        self.mask_token = '[MASK]'
+        self.special_tokens = list(self.special_tokens_map.values()) 
+
+
+    def get_vocab(self) -> Dict[str, int]:
+        return self.vocab
+
+    
+    def _tokenize(self, text, **kwargs):
+        """
+        Tokenizes the input text using LCA tokenization with an optional offset.
+
+        Args:
+            text (str): The input DNA sequence to tokenize.
+            kwargs: Additional arguments, including:
+                - offset (int): The starting position for tokenization. Default is 0.
+
+        Returns:
+            List[str]: A list of tokens generated from the input text.
+        """
+        offset = kwargs.get("offset", 0)
+        #if offset < 0 or offset >= self.config.get("shift", 1):
+        #    raise ValueError(f"Invalid offset: {offset}. Must be between 0 and {self.config['shift'] - 1}.")
+
+        return self.lca_kmer_tokenize_segment(text, offset)
+
+    def _convert_token_to_id(self, token: str) -> int:
+        """
+        Converts a token to its corresponding ID using the vocabulary.
+
+        Args:
+            token (str): The token to convert.
+
+        Returns:
+            int: Token ID, or the unknown token ID if the token is not in the vocabulary.
+        """
+        return self.extended_vocab.get(token, self.unkown_tokenid)
+
+    def _convert_id_to_token(self, index: int) -> str:
+        """
+        Converts an ID to its corresponding token using the vocabulary.
+
+        Args:
+            index (int): The ID to convert.
+
+        Returns:
+            str: Corresponding token, or the unknown token if the ID is not in the vocabulary.
+        """
+
+
+        return self.id2token.get(index, self.unk_token)
+    
+    def __len__(self) -> int:
+        """
+        Returns the length of the tokenizer's vocabulary.
+
+        The length returned is one less than the actual number of items in the vocabulary
+        to account for a specific offset or adjustment in token indexing.
+
+        :return: The adjusted length of the vocabulary.
+        :rtype: int
+        """
+        return len(self.vocab)
+
+    def lca_kmer_tokenize_segment(self, segment: str, offset: int):
+        # calculate the tokenization for one offset value
+        shift = self.shift
+        kmer = self.kmer
+        #max_segment_length = params['max_segment_length']
+        #max_unknown_token_proportion = params['max_unknown_token_proportion']
+        #kmer = params['kmer']
+        #token_limit = params['token_limit']
+        #vocabmap = params['vocabmap']
+        #add_special_token = params['add_special_token']
+        #if len(segment) > max_segment_length:
+        #    raise(ValueError(f'The segment is longer {len(segment)} then the maximum allowed segment length ({max_segment_length}). '))
+                
+        kmers = [segment[i:i + kmer] for i in range(offset, len(segment) - kmer + 1, shift)]
+
+        return kmers
+
+    def tokenize(self, text: str, **kwargs) -> List[str]:
+        """
+        Tokenizes the input text using LCA tokenization.
+
+        Args:
+            text (str): The input DNA sequence to tokenize.
+            kwargs: Additional arguments, including:
+                - offset (int): The starting position for tokenization. Default is 0.
+
+        Returns:
+            List[str]: A list of tokens generated from the input text.
+        """
+        return self._tokenize(text, **kwargs)
+
+    def encode(self, text: str,  **kwargs) -> List[int]:
+        """
+        Extends the base `encode` method to support an `offset` parameter for custom tokenization logic.
+
+        Args:
+            text (str): Input text (DNA sequence).
+            offset (int): Offset parameter for the LCA tokenization. Defaults to 0.
+            kwargs: Additional arguments passed to the base `encode` method.
+
+        Returns:
+            List[int]: Encoded token IDs.
+        """
+        # Inject the offset into kwargs for the tokenizer
+        offset = kwargs.get("offset", 0)
+        kwargs["offset"] = offset
+        return super().encode(text, **kwargs)
+
+    def build_inputs_with_special_tokens(
+        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
+    ) -> List[int]:
+        """
+        Builds inputs by adding special tokens to a sequence or pair of sequences.
+
+        Args:
+            token_ids_0 (List[int]): List of token IDs for the first sequence.
+            token_ids_1 (List[int], optional): List of token IDs for the second sequence.
+
+        Returns:
+            List[int]: Input IDs with special tokens.
+        """
+        if token_ids_1 is None:
+            return [self.cls_token_id] + token_ids_0 + [self.sep_token_id]
+        
+        input_ids = [self.cls_token_id] + token_ids_0 + [self.sep_token_id] + token_ids_1 + [self.sep_token_id]
+        #token_type_ids = [0 for i in range(len(input_ids))]
+        return input_ids
+    
+    def create_token_type_ids_from_sequences(
+        self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None
+    ) -> List[int]:
+        """
+        Create the token type IDs corresponding to the sequences passed. [What are token type
+        IDs?](../glossary#token-type-ids)
+
+        Should be overridden in a subclass if the model has a special way of building those.
+
+        Args:
+            token_ids_0 (`List[int]`): The first tokenized sequence.
+            token_ids_1 (`List[int]`, *optional*): The second tokenized sequence.
+
+        Returns:
+            `List[int]`: The token type ids.
+        """
+        if token_ids_1 is None:
+            return (len(token_ids_0)+2) * [0]
+        return [0] * len(token_ids_0) + [1] * len(token_ids_1)
+    
+    def batch_encode_plus(self, *args, **kwargs):
+        """
+        Extends the base `batch_encode_plus` method to add custom functionality if needed.
+
+        Args:
+            *args: Positional arguments passed to the base method.
+            **kwargs: Keyword arguments passed to the base method.
+
+        Returns:
+            dict: A dictionary containing the results of batch encoding.
+        """
+        # Call the parent method to handle the batch encoding
+        #print('Running batch encoding with ids')
+        act_outputs = super().batch_encode_plus(*args, **kwargs)
+        return act_outputs
+
+
+    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:
+        """
+        Saves the tokenizer's vocabulary to a file.
+
+        Args:
+            save_directory (str): Directory to save the vocabulary file.
+            filename_prefix (str, optional): Prefix for the filename. Default is None.
+
+        Returns:
+            Tuple[str]: Path to the saved vocabulary file.
+        """
+        if filename_prefix is None:
+            filename_prefix = ""
+        vocab_file_path = os.path.join(save_directory, filename_prefix + "vocab.txt")
+        with open(vocab_file_path, "w") as f:
+            for token in self.vocab:
+                f.write(token + "\n")
+        return (vocab_file_path,)
+
+
+    @property
+    def vocab_size(self) -> int:
+        """
+        Returns the size of the vocabulary (number of tokens in `vocab.txt`).
+
+        Returns:
+            int: The size of the vocabulary.
+        """
+        return len(self.vocab)
+
+    def save_pretrained(self, save_directory: str, **kwargs):
+        """
+        Save the tokenizer configuration and vocabulary to a directory.
+
+        Args:
+            save_directory (str): Directory to save the tokenizer files.
+            kwargs: Additional arguments for saving.
+        """
+        if not os.path.exists(save_directory):
+            os.makedirs(save_directory)
+
+        # Save the base tokenizer configuration
+        super().save_pretrained(save_directory, **kwargs)
+
+        # Path to the tokenizer configuration file
+        tokenizer_config_path = os.path.join(save_directory, "tokenizer_config.json")
+
+        # Load the existing configuration or create a new one
+        if os.path.exists(tokenizer_config_path):
+            with open(tokenizer_config_path, "r", encoding="utf-8") as f:
+                tokenizer_config = json.load(f)
+        else:
+            tokenizer_config = {}
+
+
+        # Add custom fields for AutoTokenizer and remote code
+        #tokenizer_config["auto_map"] = {
+        # "AutoTokenizer": "src.prokbert.tokenizer.LCATokenizer"
+        #}
+        #tokenizer_config["repository"] = "https://github.com/nbrg-ppcu/prokbert"
+        #tokenizer_config["trust_remote_code"] = True
+        tokenizer_config["kmer"] = self.kmer
+        tokenizer_config["shift"] = self.shift
+        tokenizer_config["operation_space"] = self.operation_space
+        # Save the updated configuration
+        with open(tokenizer_config_path, "w", encoding="utf-8") as f:
+            json.dump(tokenizer_config, f, indent=2)
+

tokenizer_config.json

@@ -0,0 +1,62 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenizer.LCATokenizer",
+      null
+    ]
+  },
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "[CLS]",
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "tokenizer_class": "LCATokenizer",
+  "unk_token": "[UNK]",
+  "kmer": 6,
+  "shift": 1,
+  "operation_space": "kmer"
+}

vocab.txt

@@ -0,0 +1,4101 @@
+[PAD]
+[UNK]
+[CLS]
+[SEP]
+[MASK]
+AAAAAA
+AAAAAC
+AAAAAG
+AAAAAT
+AAAACA
+AAAACC
+AAAACG
+AAAACT
+AAAAGA
+AAAAGC
+AAAAGG
+AAAAGT
+AAAATA
+AAAATC
+AAAATG
+AAAATT
+AAACAA
+AAACAC
+AAACAG
+AAACAT
+AAACCA
+AAACCC
+AAACCG
+AAACCT
+AAACGA
+AAACGC
+AAACGG
+AAACGT
+AAACTA
+AAACTC
+AAACTG
+AAACTT
+AAAGAA
+AAAGAC
+AAAGAG
+AAAGAT
+AAAGCA
+AAAGCC
+AAAGCG
+AAAGCT
+AAAGGA
+AAAGGC
+AAAGGG
+AAAGGT
+AAAGTA
+AAAGTC
+AAAGTG
+AAAGTT
+AAATAA
+AAATAC
+AAATAG
+AAATAT
+AAATCA
+AAATCC
+AAATCG
+AAATCT
+AAATGA
+AAATGC
+AAATGG
+AAATGT
+AAATTA
+AAATTC
+AAATTG
+AAATTT
+AACAAA
+AACAAC
+AACAAG
+AACAAT
+AACACA
+AACACC
+AACACG
+AACACT
+AACAGA
+AACAGC
+AACAGG
+AACAGT
+AACATA
+AACATC
+AACATG
+AACATT
+AACCAA
+AACCAC
+AACCAG
+AACCAT
+AACCCA
+AACCCC
+AACCCG
+AACCCT
+AACCGA
+AACCGC
+AACCGG
+AACCGT
+AACCTA
+AACCTC
+AACCTG
+AACCTT
+AACGAA
+AACGAC
+AACGAG
+AACGAT
+AACGCA
+AACGCC
+AACGCG
+AACGCT
+AACGGA
+AACGGC
+AACGGG
+AACGGT
+AACGTA
+AACGTC
+AACGTG
+AACGTT
+AACTAA
+AACTAC
+AACTAG
+AACTAT
+AACTCA
+AACTCC
+AACTCG
+AACTCT
+AACTGA
+AACTGC
+AACTGG
+AACTGT
+AACTTA
+AACTTC
+AACTTG
+AACTTT
+AAGAAA
+AAGAAC
+AAGAAG
+AAGAAT
+AAGACA
+AAGACC
+AAGACG
+AAGACT
+AAGAGA
+AAGAGC
+AAGAGG
+AAGAGT
+AAGATA
+AAGATC
+AAGATG
+AAGATT
+AAGCAA
+AAGCAC
+AAGCAG
+AAGCAT
+AAGCCA
+AAGCCC
+AAGCCG
+AAGCCT
+AAGCGA
+AAGCGC
+AAGCGG
+AAGCGT
+AAGCTA
+AAGCTC
+AAGCTG
+AAGCTT
+AAGGAA
+AAGGAC
+AAGGAG
+AAGGAT
+AAGGCA
+AAGGCC
+AAGGCG
+AAGGCT
+AAGGGA
+AAGGGC
+AAGGGG
+AAGGGT
+AAGGTA
+AAGGTC
+AAGGTG
+AAGGTT
+AAGTAA
+AAGTAC
+AAGTAG
+AAGTAT
+AAGTCA
+AAGTCC
+AAGTCG
+AAGTCT
+AAGTGA
+AAGTGC
+AAGTGG
+AAGTGT
+AAGTTA
+AAGTTC
+AAGTTG
+AAGTTT
+AATAAA
+AATAAC
+AATAAG
+AATAAT
+AATACA
+AATACC
+AATACG
+AATACT
+AATAGA
+AATAGC
+AATAGG
+AATAGT
+AATATA
+AATATC
+AATATG
+AATATT
+AATCAA
+AATCAC
+AATCAG
+AATCAT
+AATCCA
+AATCCC
+AATCCG
+AATCCT
+AATCGA
+AATCGC
+AATCGG
+AATCGT
+AATCTA
+AATCTC
+AATCTG
+AATCTT
+AATGAA
+AATGAC
+AATGAG
+AATGAT
+AATGCA
+AATGCC
+AATGCG
+AATGCT
+AATGGA
+AATGGC
+AATGGG
+AATGGT
+AATGTA
+AATGTC
+AATGTG
+AATGTT
+AATTAA
+AATTAC
+AATTAG
+AATTAT
+AATTCA
+AATTCC
+AATTCG
+AATTCT
+AATTGA
+AATTGC
+AATTGG
+AATTGT
+AATTTA
+AATTTC
+AATTTG
+AATTTT
+ACAAAA
+ACAAAC
+ACAAAG
+ACAAAT
+ACAACA
+ACAACC
+ACAACG
+ACAACT
+ACAAGA
+ACAAGC
+ACAAGG
+ACAAGT
+ACAATA
+ACAATC
+ACAATG
+ACAATT
+ACACAA
+ACACAC
+ACACAG
+ACACAT
+ACACCA
+ACACCC
+ACACCG
+ACACCT
+ACACGA
+ACACGC
+ACACGG
+ACACGT
+ACACTA
+ACACTC
+ACACTG
+ACACTT
+ACAGAA
+ACAGAC
+ACAGAG
+ACAGAT
+ACAGCA
+ACAGCC
+ACAGCG
+ACAGCT
+ACAGGA
+ACAGGC
+ACAGGG
+ACAGGT
+ACAGTA
+ACAGTC
+ACAGTG
+ACAGTT
+ACATAA
+ACATAC
+ACATAG
+ACATAT
+ACATCA
+ACATCC
+ACATCG
+ACATCT
+ACATGA
+ACATGC
+ACATGG
+ACATGT
+ACATTA
+ACATTC
+ACATTG
+ACATTT
+ACCAAA
+ACCAAC
+ACCAAG
+ACCAAT
+ACCACA
+ACCACC
+ACCACG
+ACCACT
+ACCAGA
+ACCAGC
+ACCAGG
+ACCAGT
+ACCATA
+ACCATC
+ACCATG
+ACCATT
+ACCCAA
+ACCCAC
+ACCCAG
+ACCCAT
+ACCCCA
+ACCCCC
+ACCCCG
+ACCCCT
+ACCCGA
+ACCCGC
+ACCCGG
+ACCCGT
+ACCCTA
+ACCCTC
+ACCCTG
+ACCCTT
+ACCGAA
+ACCGAC
+ACCGAG
+ACCGAT
+ACCGCA
+ACCGCC
+ACCGCG
+ACCGCT
+ACCGGA
+ACCGGC
+ACCGGG
+ACCGGT
+ACCGTA
+ACCGTC
+ACCGTG
+ACCGTT
+ACCTAA
+ACCTAC
+ACCTAG
+ACCTAT
+ACCTCA
+ACCTCC
+ACCTCG
+ACCTCT
+ACCTGA
+ACCTGC
+ACCTGG
+ACCTGT
+ACCTTA
+ACCTTC
+ACCTTG
+ACCTTT
+ACGAAA
+ACGAAC
+ACGAAG
+ACGAAT
+ACGACA
+ACGACC
+ACGACG
+ACGACT
+ACGAGA
+ACGAGC
+ACGAGG
+ACGAGT
+ACGATA
+ACGATC
+ACGATG
+ACGATT
+ACGCAA
+ACGCAC
+ACGCAG
+ACGCAT
+ACGCCA
+ACGCCC
+ACGCCG
+ACGCCT
+ACGCGA
+ACGCGC
+ACGCGG
+ACGCGT
+ACGCTA
+ACGCTC
+ACGCTG
+ACGCTT
+ACGGAA
+ACGGAC
+ACGGAG
+ACGGAT
+ACGGCA
+ACGGCC
+ACGGCG
+ACGGCT
+ACGGGA
+ACGGGC
+ACGGGG
+ACGGGT
+ACGGTA
+ACGGTC
+ACGGTG
+ACGGTT
+ACGTAA
+ACGTAC
+ACGTAG
+ACGTAT
+ACGTCA
+ACGTCC
+ACGTCG
+ACGTCT
+ACGTGA
+ACGTGC
+ACGTGG
+ACGTGT
+ACGTTA
+ACGTTC
+ACGTTG
+ACGTTT
+ACTAAA
+ACTAAC
+ACTAAG
+ACTAAT
+ACTACA
+ACTACC
+ACTACG
+ACTACT
+ACTAGA
+ACTAGC
+ACTAGG
+ACTAGT
+ACTATA
+ACTATC
+ACTATG
+ACTATT
+ACTCAA
+ACTCAC
+ACTCAG
+ACTCAT
+ACTCCA
+ACTCCC
+ACTCCG
+ACTCCT
+ACTCGA
+ACTCGC
+ACTCGG
+ACTCGT
+ACTCTA
+ACTCTC
+ACTCTG
+ACTCTT
+ACTGAA
+ACTGAC
+ACTGAG
+ACTGAT
+ACTGCA
+ACTGCC
+ACTGCG
+ACTGCT
+ACTGGA
+ACTGGC
+ACTGGG
+ACTGGT
+ACTGTA
+ACTGTC
+ACTGTG
+ACTGTT
+ACTTAA
+ACTTAC
+ACTTAG
+ACTTAT
+ACTTCA
+ACTTCC
+ACTTCG
+ACTTCT
+ACTTGA
+ACTTGC
+ACTTGG
+ACTTGT
+ACTTTA
+ACTTTC
+ACTTTG
+ACTTTT
+AGAAAA
+AGAAAC
+AGAAAG
+AGAAAT
+AGAACA
+AGAACC
+AGAACG
+AGAACT
+AGAAGA
+AGAAGC
+AGAAGG
+AGAAGT
+AGAATA
+AGAATC
+AGAATG
+AGAATT
+AGACAA
+AGACAC
+AGACAG
+AGACAT
+AGACCA
+AGACCC
+AGACCG
+AGACCT
+AGACGA
+AGACGC
+AGACGG
+AGACGT
+AGACTA
+AGACTC
+AGACTG
+AGACTT
+AGAGAA
+AGAGAC
+AGAGAG
+AGAGAT
+AGAGCA
+AGAGCC
+AGAGCG
+AGAGCT
+AGAGGA
+AGAGGC
+AGAGGG
+AGAGGT
+AGAGTA
+AGAGTC
+AGAGTG
+AGAGTT
+AGATAA
+AGATAC
+AGATAG
+AGATAT
+AGATCA
+AGATCC
+AGATCG
+AGATCT
+AGATGA
+AGATGC
+AGATGG
+AGATGT
+AGATTA
+AGATTC
+AGATTG
+AGATTT
+AGCAAA
+AGCAAC
+AGCAAG
+AGCAAT
+AGCACA
+AGCACC
+AGCACG
+AGCACT
+AGCAGA
+AGCAGC
+AGCAGG
+AGCAGT
+AGCATA
+AGCATC
+AGCATG
+AGCATT
+AGCCAA
+AGCCAC
+AGCCAG
+AGCCAT
+AGCCCA
+AGCCCC
+AGCCCG
+AGCCCT
+AGCCGA
+AGCCGC
+AGCCGG
+AGCCGT
+AGCCTA
+AGCCTC
+AGCCTG
+AGCCTT
+AGCGAA
+AGCGAC
+AGCGAG
+AGCGAT
+AGCGCA
+AGCGCC
+AGCGCG
+AGCGCT
+AGCGGA
+AGCGGC
+AGCGGG
+AGCGGT
+AGCGTA
+AGCGTC
+AGCGTG
+AGCGTT
+AGCTAA
+AGCTAC
+AGCTAG
+AGCTAT
+AGCTCA
+AGCTCC
+AGCTCG
+AGCTCT
+AGCTGA
+AGCTGC
+AGCTGG
+AGCTGT
+AGCTTA
+AGCTTC
+AGCTTG
+AGCTTT
+AGGAAA
+AGGAAC
+AGGAAG
+AGGAAT
+AGGACA
+AGGACC
+AGGACG
+AGGACT
+AGGAGA
+AGGAGC
+AGGAGG
+AGGAGT
+AGGATA
+AGGATC
+AGGATG
+AGGATT
+AGGCAA
+AGGCAC
+AGGCAG
+AGGCAT
+AGGCCA
+AGGCCC
+AGGCCG
+AGGCCT
+AGGCGA
+AGGCGC
+AGGCGG
+AGGCGT
+AGGCTA
+AGGCTC
+AGGCTG
+AGGCTT
+AGGGAA
+AGGGAC
+AGGGAG
+AGGGAT
+AGGGCA
+AGGGCC
+AGGGCG
+AGGGCT
+AGGGGA
+AGGGGC
+AGGGGG
+AGGGGT
+AGGGTA
+AGGGTC
+AGGGTG
+AGGGTT
+AGGTAA
+AGGTAC
+AGGTAG
+AGGTAT
+AGGTCA
+AGGTCC
+AGGTCG
+AGGTCT
+AGGTGA
+AGGTGC
+AGGTGG
+AGGTGT
+AGGTTA
+AGGTTC
+AGGTTG
+AGGTTT
+AGTAAA
+AGTAAC
+AGTAAG
+AGTAAT
+AGTACA
+AGTACC
+AGTACG
+AGTACT
+AGTAGA
+AGTAGC
+AGTAGG
+AGTAGT
+AGTATA
+AGTATC
+AGTATG
+AGTATT
+AGTCAA
+AGTCAC
+AGTCAG
+AGTCAT
+AGTCCA
+AGTCCC
+AGTCCG
+AGTCCT
+AGTCGA
+AGTCGC
+AGTCGG
+AGTCGT
+AGTCTA
+AGTCTC
+AGTCTG
+AGTCTT
+AGTGAA
+AGTGAC
+AGTGAG
+AGTGAT
+AGTGCA
+AGTGCC
+AGTGCG
+AGTGCT
+AGTGGA
+AGTGGC
+AGTGGG
+AGTGGT
+AGTGTA
+AGTGTC
+AGTGTG
+AGTGTT
+AGTTAA
+AGTTAC
+AGTTAG
+AGTTAT
+AGTTCA
+AGTTCC
+AGTTCG
+AGTTCT
+AGTTGA
+AGTTGC
+AGTTGG
+AGTTGT
+AGTTTA
+AGTTTC
+AGTTTG
+AGTTTT
+ATAAAA
+ATAAAC
+ATAAAG
+ATAAAT
+ATAACA
+ATAACC
+ATAACG
+ATAACT
+ATAAGA
+ATAAGC
+ATAAGG
+ATAAGT
+ATAATA
+ATAATC
+ATAATG
+ATAATT
+ATACAA
+ATACAC
+ATACAG
+ATACAT
+ATACCA
+ATACCC
+ATACCG
+ATACCT
+ATACGA
+ATACGC
+ATACGG
+ATACGT
+ATACTA
+ATACTC
+ATACTG
+ATACTT
+ATAGAA
+ATAGAC
+ATAGAG
+ATAGAT
+ATAGCA
+ATAGCC
+ATAGCG
+ATAGCT
+ATAGGA
+ATAGGC
+ATAGGG
+ATAGGT
+ATAGTA
+ATAGTC
+ATAGTG
+ATAGTT
+ATATAA
+ATATAC
+ATATAG
+ATATAT
+ATATCA
+ATATCC
+ATATCG
+ATATCT
+ATATGA
+ATATGC
+ATATGG
+ATATGT
+ATATTA
+ATATTC
+ATATTG
+ATATTT
+ATCAAA
+ATCAAC
+ATCAAG
+ATCAAT
+ATCACA
+ATCACC
+ATCACG
+ATCACT
+ATCAGA
+ATCAGC
+ATCAGG
+ATCAGT
+ATCATA
+ATCATC
+ATCATG
+ATCATT
+ATCCAA
+ATCCAC
+ATCCAG
+ATCCAT
+ATCCCA
+ATCCCC
+ATCCCG
+ATCCCT
+ATCCGA
+ATCCGC
+ATCCGG
+ATCCGT
+ATCCTA
+ATCCTC
+ATCCTG
+ATCCTT
+ATCGAA
+ATCGAC
+ATCGAG
+ATCGAT
+ATCGCA
+ATCGCC
+ATCGCG
+ATCGCT
+ATCGGA
+ATCGGC
+ATCGGG
+ATCGGT
+ATCGTA
+ATCGTC
+ATCGTG
+ATCGTT
+ATCTAA
+ATCTAC
+ATCTAG
+ATCTAT
+ATCTCA
+ATCTCC
+ATCTCG
+ATCTCT
+ATCTGA
+ATCTGC
+ATCTGG
+ATCTGT
+ATCTTA
+ATCTTC
+ATCTTG
+ATCTTT
+ATGAAA
+ATGAAC
+ATGAAG
+ATGAAT
+ATGACA
+ATGACC
+ATGACG
+ATGACT
+ATGAGA
+ATGAGC
+ATGAGG
+ATGAGT
+ATGATA
+ATGATC
+ATGATG
+ATGATT
+ATGCAA
+ATGCAC
+ATGCAG
+ATGCAT
+ATGCCA
+ATGCCC
+ATGCCG
+ATGCCT
+ATGCGA
+ATGCGC
+ATGCGG
+ATGCGT
+ATGCTA
+ATGCTC
+ATGCTG
+ATGCTT
+ATGGAA
+ATGGAC
+ATGGAG
+ATGGAT
+ATGGCA
+ATGGCC
+ATGGCG
+ATGGCT
+ATGGGA
+ATGGGC
+ATGGGG
+ATGGGT
+ATGGTA
+ATGGTC
+ATGGTG
+ATGGTT
+ATGTAA
+ATGTAC
+ATGTAG
+ATGTAT
+ATGTCA
+ATGTCC
+ATGTCG
+ATGTCT
+ATGTGA
+ATGTGC
+ATGTGG
+ATGTGT
+ATGTTA
+ATGTTC
+ATGTTG
+ATGTTT
+ATTAAA
+ATTAAC
+ATTAAG
+ATTAAT
+ATTACA
+ATTACC
+ATTACG
+ATTACT
+ATTAGA
+ATTAGC
+ATTAGG
+ATTAGT
+ATTATA
+ATTATC
+ATTATG
+ATTATT
+ATTCAA
+ATTCAC
+ATTCAG
+ATTCAT
+ATTCCA
+ATTCCC
+ATTCCG
+ATTCCT
+ATTCGA
+ATTCGC
+ATTCGG
+ATTCGT
+ATTCTA
+ATTCTC
+ATTCTG
+ATTCTT
+ATTGAA
+ATTGAC
+ATTGAG
+ATTGAT
+ATTGCA
+ATTGCC
+ATTGCG
+ATTGCT
+ATTGGA
+ATTGGC
+ATTGGG
+ATTGGT
+ATTGTA
+ATTGTC
+ATTGTG
+ATTGTT
+ATTTAA
+ATTTAC
+ATTTAG
+ATTTAT
+ATTTCA
+ATTTCC
+ATTTCG
+ATTTCT
+ATTTGA
+ATTTGC
+ATTTGG
+ATTTGT
+ATTTTA
+ATTTTC
+ATTTTG
+ATTTTT
+CAAAAA
+CAAAAC
+CAAAAG
+CAAAAT
+CAAACA
+CAAACC
+CAAACG
+CAAACT
+CAAAGA
+CAAAGC
+CAAAGG
+CAAAGT
+CAAATA
+CAAATC
+CAAATG
+CAAATT
+CAACAA
+CAACAC
+CAACAG
+CAACAT
+CAACCA
+CAACCC
+CAACCG
+CAACCT
+CAACGA
+CAACGC
+CAACGG
+CAACGT
+CAACTA
+CAACTC
+CAACTG
+CAACTT
+CAAGAA
+CAAGAC
+CAAGAG
+CAAGAT
+CAAGCA
+CAAGCC
+CAAGCG
+CAAGCT
+CAAGGA
+CAAGGC
+CAAGGG
+CAAGGT
+CAAGTA
+CAAGTC
+CAAGTG
+CAAGTT
+CAATAA
+CAATAC
+CAATAG
+CAATAT
+CAATCA
+CAATCC
+CAATCG
+CAATCT
+CAATGA
+CAATGC
+CAATGG
+CAATGT
+CAATTA
+CAATTC
+CAATTG
+CAATTT
+CACAAA
+CACAAC
+CACAAG
+CACAAT
+CACACA
+CACACC
+CACACG
+CACACT
+CACAGA
+CACAGC
+CACAGG
+CACAGT
+CACATA
+CACATC
+CACATG
+CACATT
+CACCAA
+CACCAC
+CACCAG
+CACCAT
+CACCCA
+CACCCC
+CACCCG
+CACCCT
+CACCGA
+CACCGC
+CACCGG
+CACCGT
+CACCTA
+CACCTC
+CACCTG
+CACCTT
+CACGAA
+CACGAC
+CACGAG
+CACGAT
+CACGCA
+CACGCC
+CACGCG
+CACGCT
+CACGGA
+CACGGC
+CACGGG
+CACGGT
+CACGTA
+CACGTC
+CACGTG
+CACGTT
+CACTAA
+CACTAC
+CACTAG
+CACTAT
+CACTCA
+CACTCC
+CACTCG
+CACTCT
+CACTGA
+CACTGC
+CACTGG
+CACTGT
+CACTTA
+CACTTC
+CACTTG
+CACTTT
+CAGAAA
+CAGAAC
+CAGAAG
+CAGAAT
+CAGACA
+CAGACC
+CAGACG
+CAGACT
+CAGAGA
+CAGAGC
+CAGAGG
+CAGAGT
+CAGATA
+CAGATC
+CAGATG
+CAGATT
+CAGCAA
+CAGCAC
+CAGCAG
+CAGCAT
+CAGCCA
+CAGCCC
+CAGCCG
+CAGCCT
+CAGCGA
+CAGCGC
+CAGCGG
+CAGCGT
+CAGCTA
+CAGCTC
+CAGCTG
+CAGCTT
+CAGGAA
+CAGGAC
+CAGGAG
+CAGGAT
+CAGGCA
+CAGGCC
+CAGGCG
+CAGGCT
+CAGGGA
+CAGGGC
+CAGGGG
+CAGGGT
+CAGGTA
+CAGGTC
+CAGGTG
+CAGGTT
+CAGTAA
+CAGTAC
+CAGTAG
+CAGTAT
+CAGTCA
+CAGTCC
+CAGTCG
+CAGTCT
+CAGTGA
+CAGTGC
+CAGTGG
+CAGTGT
+CAGTTA
+CAGTTC
+CAGTTG
+CAGTTT
+CATAAA
+CATAAC
+CATAAG
+CATAAT
+CATACA
+CATACC
+CATACG
+CATACT
+CATAGA
+CATAGC
+CATAGG
+CATAGT
+CATATA
+CATATC
+CATATG
+CATATT
+CATCAA
+CATCAC
+CATCAG
+CATCAT
+CATCCA
+CATCCC
+CATCCG
+CATCCT
+CATCGA
+CATCGC
+CATCGG
+CATCGT
+CATCTA
+CATCTC
+CATCTG
+CATCTT
+CATGAA
+CATGAC
+CATGAG
+CATGAT
+CATGCA
+CATGCC
+CATGCG
+CATGCT
+CATGGA
+CATGGC
+CATGGG
+CATGGT
+CATGTA
+CATGTC
+CATGTG
+CATGTT
+CATTAA
+CATTAC
+CATTAG
+CATTAT
+CATTCA
+CATTCC
+CATTCG
+CATTCT
+CATTGA
+CATTGC
+CATTGG
+CATTGT
+CATTTA
+CATTTC
+CATTTG
+CATTTT
+CCAAAA
+CCAAAC
+CCAAAG
+CCAAAT
+CCAACA
+CCAACC
+CCAACG
+CCAACT
+CCAAGA
+CCAAGC
+CCAAGG
+CCAAGT
+CCAATA
+CCAATC
+CCAATG
+CCAATT
+CCACAA
+CCACAC
+CCACAG
+CCACAT
+CCACCA
+CCACCC
+CCACCG
+CCACCT
+CCACGA
+CCACGC
+CCACGG
+CCACGT
+CCACTA
+CCACTC
+CCACTG
+CCACTT
+CCAGAA
+CCAGAC
+CCAGAG
+CCAGAT
+CCAGCA
+CCAGCC
+CCAGCG
+CCAGCT
+CCAGGA
+CCAGGC
+CCAGGG
+CCAGGT
+CCAGTA
+CCAGTC
+CCAGTG
+CCAGTT
+CCATAA
+CCATAC
+CCATAG
+CCATAT
+CCATCA
+CCATCC
+CCATCG
+CCATCT
+CCATGA
+CCATGC
+CCATGG
+CCATGT
+CCATTA
+CCATTC
+CCATTG
+CCATTT
+CCCAAA
+CCCAAC
+CCCAAG
+CCCAAT
+CCCACA
+CCCACC
+CCCACG
+CCCACT
+CCCAGA
+CCCAGC
+CCCAGG
+CCCAGT
+CCCATA
+CCCATC
+CCCATG
+CCCATT
+CCCCAA
+CCCCAC
+CCCCAG
+CCCCAT
+CCCCCA
+CCCCCC
+CCCCCG
+CCCCCT
+CCCCGA
+CCCCGC
+CCCCGG
+CCCCGT
+CCCCTA
+CCCCTC
+CCCCTG
+CCCCTT
+CCCGAA
+CCCGAC
+CCCGAG
+CCCGAT
+CCCGCA
+CCCGCC
+CCCGCG
+CCCGCT
+CCCGGA
+CCCGGC
+CCCGGG
+CCCGGT
+CCCGTA
+CCCGTC
+CCCGTG
+CCCGTT
+CCCTAA
+CCCTAC
+CCCTAG
+CCCTAT
+CCCTCA
+CCCTCC
+CCCTCG
+CCCTCT
+CCCTGA
+CCCTGC
+CCCTGG
+CCCTGT
+CCCTTA
+CCCTTC
+CCCTTG
+CCCTTT
+CCGAAA
+CCGAAC
+CCGAAG
+CCGAAT
+CCGACA
+CCGACC
+CCGACG
+CCGACT
+CCGAGA
+CCGAGC
+CCGAGG
+CCGAGT
+CCGATA
+CCGATC
+CCGATG
+CCGATT
+CCGCAA
+CCGCAC
+CCGCAG
+CCGCAT
+CCGCCA
+CCGCCC
+CCGCCG
+CCGCCT
+CCGCGA
+CCGCGC
+CCGCGG
+CCGCGT
+CCGCTA
+CCGCTC
+CCGCTG
+CCGCTT
+CCGGAA
+CCGGAC
+CCGGAG
+CCGGAT
+CCGGCA
+CCGGCC
+CCGGCG
+CCGGCT
+CCGGGA
+CCGGGC
+CCGGGG
+CCGGGT
+CCGGTA
+CCGGTC
+CCGGTG
+CCGGTT
+CCGTAA
+CCGTAC
+CCGTAG
+CCGTAT
+CCGTCA
+CCGTCC
+CCGTCG
+CCGTCT
+CCGTGA
+CCGTGC
+CCGTGG
+CCGTGT
+CCGTTA
+CCGTTC
+CCGTTG
+CCGTTT
+CCTAAA
+CCTAAC
+CCTAAG
+CCTAAT
+CCTACA
+CCTACC
+CCTACG
+CCTACT
+CCTAGA
+CCTAGC
+CCTAGG
+CCTAGT
+CCTATA
+CCTATC
+CCTATG
+CCTATT
+CCTCAA
+CCTCAC
+CCTCAG
+CCTCAT
+CCTCCA
+CCTCCC
+CCTCCG
+CCTCCT
+CCTCGA
+CCTCGC
+CCTCGG
+CCTCGT
+CCTCTA
+CCTCTC
+CCTCTG
+CCTCTT
+CCTGAA
+CCTGAC
+CCTGAG
+CCTGAT
+CCTGCA
+CCTGCC
+CCTGCG
+CCTGCT
+CCTGGA
+CCTGGC
+CCTGGG
+CCTGGT
+CCTGTA
+CCTGTC
+CCTGTG
+CCTGTT
+CCTTAA
+CCTTAC
+CCTTAG
+CCTTAT
+CCTTCA
+CCTTCC
+CCTTCG
+CCTTCT
+CCTTGA
+CCTTGC
+CCTTGG
+CCTTGT
+CCTTTA
+CCTTTC
+CCTTTG
+CCTTTT
+CGAAAA
+CGAAAC
+CGAAAG
+CGAAAT
+CGAACA
+CGAACC
+CGAACG
+CGAACT
+CGAAGA
+CGAAGC
+CGAAGG
+CGAAGT
+CGAATA
+CGAATC
+CGAATG
+CGAATT
+CGACAA
+CGACAC
+CGACAG
+CGACAT
+CGACCA
+CGACCC
+CGACCG
+CGACCT
+CGACGA
+CGACGC
+CGACGG
+CGACGT
+CGACTA
+CGACTC
+CGACTG
+CGACTT
+CGAGAA
+CGAGAC
+CGAGAG
+CGAGAT
+CGAGCA
+CGAGCC
+CGAGCG
+CGAGCT
+CGAGGA
+CGAGGC
+CGAGGG
+CGAGGT
+CGAGTA
+CGAGTC
+CGAGTG
+CGAGTT
+CGATAA
+CGATAC
+CGATAG
+CGATAT
+CGATCA
+CGATCC
+CGATCG
+CGATCT
+CGATGA
+CGATGC
+CGATGG
+CGATGT
+CGATTA
+CGATTC
+CGATTG
+CGATTT
+CGCAAA
+CGCAAC
+CGCAAG
+CGCAAT
+CGCACA
+CGCACC
+CGCACG
+CGCACT
+CGCAGA
+CGCAGC
+CGCAGG
+CGCAGT
+CGCATA
+CGCATC
+CGCATG
+CGCATT
+CGCCAA
+CGCCAC
+CGCCAG
+CGCCAT
+CGCCCA
+CGCCCC
+CGCCCG
+CGCCCT
+CGCCGA
+CGCCGC
+CGCCGG
+CGCCGT
+CGCCTA
+CGCCTC
+CGCCTG
+CGCCTT
+CGCGAA
+CGCGAC
+CGCGAG
+CGCGAT
+CGCGCA
+CGCGCC
+CGCGCG
+CGCGCT
+CGCGGA
+CGCGGC
+CGCGGG
+CGCGGT
+CGCGTA
+CGCGTC
+CGCGTG
+CGCGTT
+CGCTAA
+CGCTAC
+CGCTAG
+CGCTAT
+CGCTCA
+CGCTCC
+CGCTCG
+CGCTCT
+CGCTGA
+CGCTGC
+CGCTGG
+CGCTGT
+CGCTTA
+CGCTTC
+CGCTTG
+CGCTTT
+CGGAAA
+CGGAAC
+CGGAAG
+CGGAAT
+CGGACA
+CGGACC
+CGGACG
+CGGACT
+CGGAGA
+CGGAGC
+CGGAGG
+CGGAGT
+CGGATA
+CGGATC
+CGGATG
+CGGATT
+CGGCAA
+CGGCAC
+CGGCAG
+CGGCAT
+CGGCCA
+CGGCCC
+CGGCCG
+CGGCCT
+CGGCGA
+CGGCGC
+CGGCGG
+CGGCGT
+CGGCTA
+CGGCTC
+CGGCTG
+CGGCTT
+CGGGAA
+CGGGAC
+CGGGAG
+CGGGAT
+CGGGCA
+CGGGCC
+CGGGCG
+CGGGCT
+CGGGGA
+CGGGGC
+CGGGGG
+CGGGGT
+CGGGTA
+CGGGTC
+CGGGTG
+CGGGTT
+CGGTAA
+CGGTAC
+CGGTAG
+CGGTAT
+CGGTCA
+CGGTCC
+CGGTCG
+CGGTCT
+CGGTGA
+CGGTGC
+CGGTGG
+CGGTGT
+CGGTTA
+CGGTTC
+CGGTTG
+CGGTTT
+CGTAAA
+CGTAAC
+CGTAAG
+CGTAAT
+CGTACA
+CGTACC
+CGTACG
+CGTACT
+CGTAGA
+CGTAGC
+CGTAGG
+CGTAGT
+CGTATA
+CGTATC
+CGTATG
+CGTATT
+CGTCAA
+CGTCAC
+CGTCAG
+CGTCAT
+CGTCCA
+CGTCCC
+CGTCCG
+CGTCCT
+CGTCGA
+CGTCGC
+CGTCGG
+CGTCGT
+CGTCTA
+CGTCTC
+CGTCTG
+CGTCTT
+CGTGAA
+CGTGAC
+CGTGAG
+CGTGAT
+CGTGCA
+CGTGCC
+CGTGCG
+CGTGCT
+CGTGGA
+CGTGGC
+CGTGGG
+CGTGGT
+CGTGTA
+CGTGTC
+CGTGTG
+CGTGTT
+CGTTAA
+CGTTAC
+CGTTAG
+CGTTAT
+CGTTCA
+CGTTCC
+CGTTCG
+CGTTCT
+CGTTGA
+CGTTGC
+CGTTGG
+CGTTGT
+CGTTTA
+CGTTTC
+CGTTTG
+CGTTTT
+CTAAAA
+CTAAAC
+CTAAAG
+CTAAAT
+CTAACA
+CTAACC
+CTAACG
+CTAACT
+CTAAGA
+CTAAGC
+CTAAGG
+CTAAGT
+CTAATA
+CTAATC
+CTAATG
+CTAATT
+CTACAA
+CTACAC
+CTACAG
+CTACAT
+CTACCA
+CTACCC
+CTACCG
+CTACCT
+CTACGA
+CTACGC
+CTACGG
+CTACGT
+CTACTA
+CTACTC
+CTACTG
+CTACTT
+CTAGAA
+CTAGAC
+CTAGAG
+CTAGAT
+CTAGCA
+CTAGCC
+CTAGCG
+CTAGCT
+CTAGGA
+CTAGGC
+CTAGGG
+CTAGGT
+CTAGTA
+CTAGTC
+CTAGTG
+CTAGTT
+CTATAA
+CTATAC
+CTATAG
+CTATAT
+CTATCA
+CTATCC
+CTATCG
+CTATCT
+CTATGA
+CTATGC
+CTATGG
+CTATGT
+CTATTA
+CTATTC
+CTATTG
+CTATTT
+CTCAAA
+CTCAAC
+CTCAAG
+CTCAAT
+CTCACA
+CTCACC
+CTCACG
+CTCACT
+CTCAGA
+CTCAGC
+CTCAGG
+CTCAGT
+CTCATA
+CTCATC
+CTCATG
+CTCATT
+CTCCAA
+CTCCAC
+CTCCAG
+CTCCAT
+CTCCCA
+CTCCCC
+CTCCCG
+CTCCCT
+CTCCGA
+CTCCGC
+CTCCGG
+CTCCGT
+CTCCTA
+CTCCTC
+CTCCTG
+CTCCTT
+CTCGAA
+CTCGAC
+CTCGAG
+CTCGAT
+CTCGCA
+CTCGCC
+CTCGCG
+CTCGCT
+CTCGGA
+CTCGGC
+CTCGGG
+CTCGGT
+CTCGTA
+CTCGTC
+CTCGTG
+CTCGTT
+CTCTAA
+CTCTAC
+CTCTAG
+CTCTAT
+CTCTCA
+CTCTCC
+CTCTCG
+CTCTCT
+CTCTGA
+CTCTGC
+CTCTGG
+CTCTGT
+CTCTTA
+CTCTTC
+CTCTTG
+CTCTTT
+CTGAAA
+CTGAAC
+CTGAAG
+CTGAAT
+CTGACA
+CTGACC
+CTGACG
+CTGACT
+CTGAGA
+CTGAGC
+CTGAGG
+CTGAGT
+CTGATA
+CTGATC
+CTGATG
+CTGATT
+CTGCAA
+CTGCAC
+CTGCAG
+CTGCAT
+CTGCCA
+CTGCCC
+CTGCCG
+CTGCCT
+CTGCGA
+CTGCGC
+CTGCGG
+CTGCGT
+CTGCTA
+CTGCTC
+CTGCTG
+CTGCTT
+CTGGAA
+CTGGAC
+CTGGAG
+CTGGAT
+CTGGCA
+CTGGCC
+CTGGCG
+CTGGCT
+CTGGGA
+CTGGGC
+CTGGGG
+CTGGGT
+CTGGTA
+CTGGTC
+CTGGTG
+CTGGTT
+CTGTAA
+CTGTAC
+CTGTAG
+CTGTAT
+CTGTCA
+CTGTCC
+CTGTCG
+CTGTCT
+CTGTGA
+CTGTGC
+CTGTGG
+CTGTGT
+CTGTTA
+CTGTTC
+CTGTTG
+CTGTTT
+CTTAAA
+CTTAAC
+CTTAAG
+CTTAAT
+CTTACA
+CTTACC
+CTTACG
+CTTACT
+CTTAGA
+CTTAGC
+CTTAGG
+CTTAGT
+CTTATA
+CTTATC
+CTTATG
+CTTATT
+CTTCAA
+CTTCAC
+CTTCAG
+CTTCAT
+CTTCCA
+CTTCCC
+CTTCCG
+CTTCCT
+CTTCGA
+CTTCGC
+CTTCGG
+CTTCGT
+CTTCTA
+CTTCTC
+CTTCTG
+CTTCTT
+CTTGAA
+CTTGAC
+CTTGAG
+CTTGAT
+CTTGCA
+CTTGCC
+CTTGCG
+CTTGCT
+CTTGGA
+CTTGGC
+CTTGGG
+CTTGGT
+CTTGTA
+CTTGTC
+CTTGTG
+CTTGTT
+CTTTAA
+CTTTAC
+CTTTAG
+CTTTAT
+CTTTCA
+CTTTCC
+CTTTCG
+CTTTCT
+CTTTGA
+CTTTGC
+CTTTGG
+CTTTGT
+CTTTTA
+CTTTTC
+CTTTTG
+CTTTTT
+GAAAAA
+GAAAAC
+GAAAAG
+GAAAAT
+GAAACA
+GAAACC
+GAAACG
+GAAACT
+GAAAGA
+GAAAGC
+GAAAGG
+GAAAGT
+GAAATA
+GAAATC
+GAAATG
+GAAATT
+GAACAA
+GAACAC
+GAACAG
+GAACAT
+GAACCA
+GAACCC
+GAACCG
+GAACCT
+GAACGA
+GAACGC
+GAACGG
+GAACGT
+GAACTA
+GAACTC
+GAACTG
+GAACTT
+GAAGAA
+GAAGAC
+GAAGAG
+GAAGAT
+GAAGCA
+GAAGCC
+GAAGCG
+GAAGCT
+GAAGGA
+GAAGGC
+GAAGGG
+GAAGGT
+GAAGTA
+GAAGTC
+GAAGTG
+GAAGTT
+GAATAA
+GAATAC
+GAATAG
+GAATAT
+GAATCA
+GAATCC
+GAATCG
+GAATCT
+GAATGA
+GAATGC
+GAATGG
+GAATGT
+GAATTA
+GAATTC
+GAATTG
+GAATTT
+GACAAA
+GACAAC
+GACAAG
+GACAAT
+GACACA
+GACACC
+GACACG
+GACACT
+GACAGA
+GACAGC
+GACAGG
+GACAGT
+GACATA
+GACATC
+GACATG
+GACATT
+GACCAA
+GACCAC
+GACCAG
+GACCAT
+GACCCA
+GACCCC
+GACCCG
+GACCCT
+GACCGA
+GACCGC
+GACCGG
+GACCGT
+GACCTA
+GACCTC
+GACCTG
+GACCTT
+GACGAA
+GACGAC
+GACGAG
+GACGAT
+GACGCA
+GACGCC
+GACGCG
+GACGCT
+GACGGA
+GACGGC
+GACGGG
+GACGGT
+GACGTA
+GACGTC
+GACGTG
+GACGTT
+GACTAA
+GACTAC
+GACTAG
+GACTAT
+GACTCA
+GACTCC
+GACTCG
+GACTCT
+GACTGA
+GACTGC
+GACTGG
+GACTGT
+GACTTA
+GACTTC
+GACTTG
+GACTTT
+GAGAAA
+GAGAAC
+GAGAAG
+GAGAAT
+GAGACA
+GAGACC
+GAGACG
+GAGACT
+GAGAGA
+GAGAGC
+GAGAGG
+GAGAGT
+GAGATA
+GAGATC
+GAGATG
+GAGATT
+GAGCAA
+GAGCAC
+GAGCAG
+GAGCAT
+GAGCCA
+GAGCCC
+GAGCCG
+GAGCCT
+GAGCGA
+GAGCGC
+GAGCGG
+GAGCGT
+GAGCTA
+GAGCTC
+GAGCTG
+GAGCTT
+GAGGAA
+GAGGAC
+GAGGAG
+GAGGAT
+GAGGCA
+GAGGCC
+GAGGCG
+GAGGCT
+GAGGGA
+GAGGGC
+GAGGGG
+GAGGGT
+GAGGTA
+GAGGTC
+GAGGTG
+GAGGTT
+GAGTAA
+GAGTAC
+GAGTAG
+GAGTAT
+GAGTCA
+GAGTCC
+GAGTCG
+GAGTCT
+GAGTGA
+GAGTGC
+GAGTGG
+GAGTGT
+GAGTTA
+GAGTTC
+GAGTTG
+GAGTTT
+GATAAA
+GATAAC
+GATAAG
+GATAAT
+GATACA
+GATACC
+GATACG
+GATACT
+GATAGA
+GATAGC
+GATAGG
+GATAGT
+GATATA
+GATATC
+GATATG
+GATATT
+GATCAA
+GATCAC
+GATCAG
+GATCAT
+GATCCA
+GATCCC
+GATCCG
+GATCCT
+GATCGA
+GATCGC
+GATCGG
+GATCGT
+GATCTA
+GATCTC
+GATCTG
+GATCTT
+GATGAA
+GATGAC
+GATGAG
+GATGAT
+GATGCA
+GATGCC
+GATGCG
+GATGCT
+GATGGA
+GATGGC
+GATGGG
+GATGGT
+GATGTA
+GATGTC
+GATGTG
+GATGTT
+GATTAA
+GATTAC
+GATTAG
+GATTAT
+GATTCA
+GATTCC
+GATTCG
+GATTCT
+GATTGA
+GATTGC
+GATTGG
+GATTGT
+GATTTA
+GATTTC
+GATTTG
+GATTTT
+GCAAAA
+GCAAAC
+GCAAAG
+GCAAAT
+GCAACA
+GCAACC
+GCAACG
+GCAACT
+GCAAGA
+GCAAGC
+GCAAGG
+GCAAGT
+GCAATA
+GCAATC
+GCAATG
+GCAATT
+GCACAA
+GCACAC
+GCACAG
+GCACAT
+GCACCA
+GCACCC
+GCACCG
+GCACCT
+GCACGA
+GCACGC
+GCACGG
+GCACGT
+GCACTA
+GCACTC
+GCACTG
+GCACTT
+GCAGAA
+GCAGAC
+GCAGAG
+GCAGAT
+GCAGCA
+GCAGCC
+GCAGCG
+GCAGCT
+GCAGGA
+GCAGGC
+GCAGGG
+GCAGGT
+GCAGTA
+GCAGTC
+GCAGTG
+GCAGTT
+GCATAA
+GCATAC
+GCATAG
+GCATAT
+GCATCA
+GCATCC
+GCATCG
+GCATCT
+GCATGA
+GCATGC
+GCATGG
+GCATGT
+GCATTA
+GCATTC
+GCATTG
+GCATTT
+GCCAAA
+GCCAAC
+GCCAAG
+GCCAAT
+GCCACA
+GCCACC
+GCCACG
+GCCACT
+GCCAGA
+GCCAGC
+GCCAGG
+GCCAGT
+GCCATA
+GCCATC
+GCCATG
+GCCATT
+GCCCAA
+GCCCAC
+GCCCAG
+GCCCAT
+GCCCCA
+GCCCCC
+GCCCCG
+GCCCCT
+GCCCGA
+GCCCGC
+GCCCGG
+GCCCGT
+GCCCTA
+GCCCTC
+GCCCTG
+GCCCTT
+GCCGAA
+GCCGAC
+GCCGAG
+GCCGAT
+GCCGCA
+GCCGCC
+GCCGCG
+GCCGCT
+GCCGGA
+GCCGGC
+GCCGGG
+GCCGGT
+GCCGTA
+GCCGTC
+GCCGTG
+GCCGTT
+GCCTAA
+GCCTAC
+GCCTAG
+GCCTAT
+GCCTCA
+GCCTCC
+GCCTCG
+GCCTCT
+GCCTGA
+GCCTGC
+GCCTGG
+GCCTGT
+GCCTTA
+GCCTTC
+GCCTTG
+GCCTTT
+GCGAAA
+GCGAAC
+GCGAAG
+GCGAAT
+GCGACA
+GCGACC
+GCGACG
+GCGACT
+GCGAGA
+GCGAGC
+GCGAGG
+GCGAGT
+GCGATA
+GCGATC
+GCGATG
+GCGATT
+GCGCAA
+GCGCAC
+GCGCAG
+GCGCAT
+GCGCCA
+GCGCCC
+GCGCCG
+GCGCCT
+GCGCGA
+GCGCGC
+GCGCGG
+GCGCGT
+GCGCTA
+GCGCTC
+GCGCTG
+GCGCTT
+GCGGAA
+GCGGAC
+GCGGAG
+GCGGAT
+GCGGCA
+GCGGCC
+GCGGCG
+GCGGCT
+GCGGGA
+GCGGGC
+GCGGGG
+GCGGGT
+GCGGTA
+GCGGTC
+GCGGTG
+GCGGTT
+GCGTAA
+GCGTAC
+GCGTAG
+GCGTAT
+GCGTCA
+GCGTCC
+GCGTCG
+GCGTCT
+GCGTGA
+GCGTGC
+GCGTGG
+GCGTGT
+GCGTTA
+GCGTTC
+GCGTTG
+GCGTTT
+GCTAAA
+GCTAAC
+GCTAAG
+GCTAAT
+GCTACA
+GCTACC
+GCTACG
+GCTACT
+GCTAGA
+GCTAGC
+GCTAGG
+GCTAGT
+GCTATA
+GCTATC
+GCTATG
+GCTATT
+GCTCAA
+GCTCAC
+GCTCAG
+GCTCAT
+GCTCCA
+GCTCCC
+GCTCCG
+GCTCCT
+GCTCGA
+GCTCGC
+GCTCGG
+GCTCGT
+GCTCTA
+GCTCTC
+GCTCTG
+GCTCTT
+GCTGAA
+GCTGAC
+GCTGAG
+GCTGAT
+GCTGCA
+GCTGCC
+GCTGCG
+GCTGCT
+GCTGGA
+GCTGGC
+GCTGGG
+GCTGGT
+GCTGTA
+GCTGTC
+GCTGTG
+GCTGTT
+GCTTAA
+GCTTAC
+GCTTAG
+GCTTAT
+GCTTCA
+GCTTCC
+GCTTCG
+GCTTCT
+GCTTGA
+GCTTGC
+GCTTGG
+GCTTGT
+GCTTTA
+GCTTTC
+GCTTTG
+GCTTTT
+GGAAAA
+GGAAAC
+GGAAAG
+GGAAAT
+GGAACA
+GGAACC
+GGAACG
+GGAACT
+GGAAGA
+GGAAGC
+GGAAGG
+GGAAGT
+GGAATA
+GGAATC
+GGAATG
+GGAATT
+GGACAA
+GGACAC
+GGACAG
+GGACAT
+GGACCA
+GGACCC
+GGACCG
+GGACCT
+GGACGA
+GGACGC
+GGACGG
+GGACGT
+GGACTA
+GGACTC
+GGACTG
+GGACTT
+GGAGAA
+GGAGAC
+GGAGAG
+GGAGAT
+GGAGCA
+GGAGCC
+GGAGCG
+GGAGCT
+GGAGGA
+GGAGGC
+GGAGGG
+GGAGGT
+GGAGTA
+GGAGTC
+GGAGTG
+GGAGTT
+GGATAA
+GGATAC
+GGATAG
+GGATAT
+GGATCA
+GGATCC
+GGATCG
+GGATCT
+GGATGA
+GGATGC
+GGATGG
+GGATGT
+GGATTA
+GGATTC
+GGATTG
+GGATTT
+GGCAAA
+GGCAAC
+GGCAAG
+GGCAAT
+GGCACA
+GGCACC
+GGCACG
+GGCACT
+GGCAGA
+GGCAGC
+GGCAGG
+GGCAGT
+GGCATA
+GGCATC
+GGCATG
+GGCATT
+GGCCAA
+GGCCAC
+GGCCAG
+GGCCAT
+GGCCCA
+GGCCCC
+GGCCCG
+GGCCCT
+GGCCGA
+GGCCGC
+GGCCGG
+GGCCGT
+GGCCTA
+GGCCTC
+GGCCTG
+GGCCTT
+GGCGAA
+GGCGAC
+GGCGAG
+GGCGAT
+GGCGCA
+GGCGCC
+GGCGCG
+GGCGCT
+GGCGGA
+GGCGGC
+GGCGGG
+GGCGGT
+GGCGTA
+GGCGTC
+GGCGTG
+GGCGTT
+GGCTAA
+GGCTAC
+GGCTAG
+GGCTAT
+GGCTCA
+GGCTCC
+GGCTCG
+GGCTCT
+GGCTGA
+GGCTGC
+GGCTGG
+GGCTGT
+GGCTTA
+GGCTTC
+GGCTTG
+GGCTTT
+GGGAAA
+GGGAAC
+GGGAAG
+GGGAAT
+GGGACA
+GGGACC
+GGGACG
+GGGACT
+GGGAGA
+GGGAGC
+GGGAGG
+GGGAGT
+GGGATA
+GGGATC
+GGGATG
+GGGATT
+GGGCAA
+GGGCAC
+GGGCAG
+GGGCAT
+GGGCCA
+GGGCCC
+GGGCCG
+GGGCCT
+GGGCGA
+GGGCGC
+GGGCGG
+GGGCGT
+GGGCTA
+GGGCTC
+GGGCTG
+GGGCTT
+GGGGAA
+GGGGAC
+GGGGAG
+GGGGAT
+GGGGCA
+GGGGCC
+GGGGCG
+GGGGCT
+GGGGGA
+GGGGGC
+GGGGGG
+GGGGGT
+GGGGTA
+GGGGTC
+GGGGTG
+GGGGTT
+GGGTAA
+GGGTAC
+GGGTAG
+GGGTAT
+GGGTCA
+GGGTCC
+GGGTCG
+GGGTCT
+GGGTGA
+GGGTGC
+GGGTGG
+GGGTGT
+GGGTTA
+GGGTTC
+GGGTTG
+GGGTTT
+GGTAAA
+GGTAAC
+GGTAAG
+GGTAAT
+GGTACA
+GGTACC
+GGTACG
+GGTACT
+GGTAGA
+GGTAGC
+GGTAGG
+GGTAGT
+GGTATA
+GGTATC
+GGTATG
+GGTATT
+GGTCAA
+GGTCAC
+GGTCAG
+GGTCAT
+GGTCCA
+GGTCCC
+GGTCCG
+GGTCCT
+GGTCGA
+GGTCGC
+GGTCGG
+GGTCGT
+GGTCTA
+GGTCTC
+GGTCTG
+GGTCTT
+GGTGAA
+GGTGAC
+GGTGAG
+GGTGAT
+GGTGCA
+GGTGCC
+GGTGCG
+GGTGCT
+GGTGGA
+GGTGGC
+GGTGGG
+GGTGGT
+GGTGTA
+GGTGTC
+GGTGTG
+GGTGTT
+GGTTAA
+GGTTAC
+GGTTAG
+GGTTAT
+GGTTCA
+GGTTCC
+GGTTCG
+GGTTCT
+GGTTGA
+GGTTGC
+GGTTGG
+GGTTGT
+GGTTTA
+GGTTTC
+GGTTTG
+GGTTTT
+GTAAAA
+GTAAAC
+GTAAAG
+GTAAAT
+GTAACA
+GTAACC
+GTAACG
+GTAACT
+GTAAGA
+GTAAGC
+GTAAGG
+GTAAGT
+GTAATA
+GTAATC
+GTAATG
+GTAATT
+GTACAA
+GTACAC
+GTACAG
+GTACAT
+GTACCA
+GTACCC
+GTACCG
+GTACCT
+GTACGA
+GTACGC
+GTACGG
+GTACGT
+GTACTA
+GTACTC
+GTACTG
+GTACTT
+GTAGAA
+GTAGAC
+GTAGAG
+GTAGAT
+GTAGCA
+GTAGCC
+GTAGCG
+GTAGCT
+GTAGGA
+GTAGGC
+GTAGGG
+GTAGGT
+GTAGTA
+GTAGTC
+GTAGTG
+GTAGTT
+GTATAA
+GTATAC
+GTATAG
+GTATAT
+GTATCA
+GTATCC
+GTATCG
+GTATCT
+GTATGA
+GTATGC
+GTATGG
+GTATGT
+GTATTA
+GTATTC
+GTATTG
+GTATTT
+GTCAAA
+GTCAAC
+GTCAAG
+GTCAAT
+GTCACA
+GTCACC
+GTCACG
+GTCACT
+GTCAGA
+GTCAGC
+GTCAGG
+GTCAGT
+GTCATA
+GTCATC
+GTCATG
+GTCATT
+GTCCAA
+GTCCAC
+GTCCAG
+GTCCAT
+GTCCCA
+GTCCCC
+GTCCCG
+GTCCCT
+GTCCGA
+GTCCGC
+GTCCGG
+GTCCGT
+GTCCTA
+GTCCTC
+GTCCTG
+GTCCTT
+GTCGAA
+GTCGAC
+GTCGAG
+GTCGAT
+GTCGCA
+GTCGCC
+GTCGCG
+GTCGCT
+GTCGGA
+GTCGGC
+GTCGGG
+GTCGGT
+GTCGTA
+GTCGTC
+GTCGTG
+GTCGTT
+GTCTAA
+GTCTAC
+GTCTAG
+GTCTAT
+GTCTCA
+GTCTCC
+GTCTCG
+GTCTCT
+GTCTGA
+GTCTGC
+GTCTGG
+GTCTGT
+GTCTTA
+GTCTTC
+GTCTTG
+GTCTTT
+GTGAAA
+GTGAAC
+GTGAAG
+GTGAAT
+GTGACA
+GTGACC
+GTGACG
+GTGACT
+GTGAGA
+GTGAGC
+GTGAGG
+GTGAGT
+GTGATA
+GTGATC
+GTGATG
+GTGATT
+GTGCAA
+GTGCAC
+GTGCAG
+GTGCAT
+GTGCCA
+GTGCCC
+GTGCCG
+GTGCCT
+GTGCGA
+GTGCGC
+GTGCGG
+GTGCGT
+GTGCTA
+GTGCTC
+GTGCTG
+GTGCTT
+GTGGAA
+GTGGAC
+GTGGAG
+GTGGAT
+GTGGCA
+GTGGCC
+GTGGCG
+GTGGCT
+GTGGGA
+GTGGGC
+GTGGGG
+GTGGGT
+GTGGTA
+GTGGTC
+GTGGTG
+GTGGTT
+GTGTAA
+GTGTAC
+GTGTAG
+GTGTAT
+GTGTCA
+GTGTCC
+GTGTCG
+GTGTCT
+GTGTGA
+GTGTGC
+GTGTGG
+GTGTGT
+GTGTTA
+GTGTTC
+GTGTTG
+GTGTTT
+GTTAAA
+GTTAAC
+GTTAAG
+GTTAAT
+GTTACA
+GTTACC
+GTTACG
+GTTACT
+GTTAGA
+GTTAGC
+GTTAGG
+GTTAGT
+GTTATA
+GTTATC
+GTTATG
+GTTATT
+GTTCAA
+GTTCAC
+GTTCAG
+GTTCAT
+GTTCCA
+GTTCCC
+GTTCCG
+GTTCCT
+GTTCGA
+GTTCGC
+GTTCGG
+GTTCGT
+GTTCTA
+GTTCTC
+GTTCTG
+GTTCTT
+GTTGAA
+GTTGAC
+GTTGAG
+GTTGAT
+GTTGCA
+GTTGCC
+GTTGCG
+GTTGCT
+GTTGGA
+GTTGGC
+GTTGGG
+GTTGGT
+GTTGTA
+GTTGTC
+GTTGTG
+GTTGTT
+GTTTAA
+GTTTAC
+GTTTAG
+GTTTAT
+GTTTCA
+GTTTCC
+GTTTCG
+GTTTCT
+GTTTGA
+GTTTGC
+GTTTGG
+GTTTGT
+GTTTTA
+GTTTTC
+GTTTTG
+GTTTTT
+TAAAAA
+TAAAAC
+TAAAAG
+TAAAAT
+TAAACA
+TAAACC
+TAAACG
+TAAACT
+TAAAGA
+TAAAGC
+TAAAGG
+TAAAGT
+TAAATA
+TAAATC
+TAAATG
+TAAATT
+TAACAA
+TAACAC
+TAACAG
+TAACAT
+TAACCA
+TAACCC
+TAACCG
+TAACCT
+TAACGA
+TAACGC
+TAACGG
+TAACGT
+TAACTA
+TAACTC
+TAACTG
+TAACTT
+TAAGAA
+TAAGAC
+TAAGAG
+TAAGAT
+TAAGCA
+TAAGCC
+TAAGCG
+TAAGCT
+TAAGGA
+TAAGGC
+TAAGGG
+TAAGGT
+TAAGTA
+TAAGTC
+TAAGTG
+TAAGTT
+TAATAA
+TAATAC
+TAATAG
+TAATAT
+TAATCA
+TAATCC
+TAATCG
+TAATCT
+TAATGA
+TAATGC
+TAATGG
+TAATGT
+TAATTA
+TAATTC
+TAATTG
+TAATTT
+TACAAA
+TACAAC
+TACAAG
+TACAAT
+TACACA
+TACACC
+TACACG
+TACACT
+TACAGA
+TACAGC
+TACAGG
+TACAGT
+TACATA
+TACATC
+TACATG
+TACATT
+TACCAA
+TACCAC
+TACCAG
+TACCAT
+TACCCA
+TACCCC
+TACCCG
+TACCCT
+TACCGA
+TACCGC
+TACCGG
+TACCGT
+TACCTA
+TACCTC
+TACCTG
+TACCTT
+TACGAA
+TACGAC
+TACGAG
+TACGAT
+TACGCA
+TACGCC
+TACGCG
+TACGCT
+TACGGA
+TACGGC
+TACGGG
+TACGGT
+TACGTA
+TACGTC
+TACGTG
+TACGTT
+TACTAA
+TACTAC
+TACTAG
+TACTAT
+TACTCA
+TACTCC
+TACTCG
+TACTCT
+TACTGA
+TACTGC
+TACTGG
+TACTGT
+TACTTA
+TACTTC
+TACTTG
+TACTTT
+TAGAAA
+TAGAAC
+TAGAAG
+TAGAAT
+TAGACA
+TAGACC
+TAGACG
+TAGACT
+TAGAGA
+TAGAGC
+TAGAGG
+TAGAGT
+TAGATA
+TAGATC
+TAGATG
+TAGATT
+TAGCAA
+TAGCAC
+TAGCAG
+TAGCAT
+TAGCCA
+TAGCCC
+TAGCCG
+TAGCCT
+TAGCGA
+TAGCGC
+TAGCGG
+TAGCGT
+TAGCTA
+TAGCTC
+TAGCTG
+TAGCTT
+TAGGAA
+TAGGAC
+TAGGAG
+TAGGAT
+TAGGCA
+TAGGCC
+TAGGCG
+TAGGCT
+TAGGGA
+TAGGGC
+TAGGGG
+TAGGGT
+TAGGTA
+TAGGTC
+TAGGTG
+TAGGTT
+TAGTAA
+TAGTAC
+TAGTAG
+TAGTAT
+TAGTCA
+TAGTCC
+TAGTCG
+TAGTCT
+TAGTGA
+TAGTGC
+TAGTGG
+TAGTGT
+TAGTTA
+TAGTTC
+TAGTTG
+TAGTTT
+TATAAA
+TATAAC
+TATAAG
+TATAAT
+TATACA
+TATACC
+TATACG
+TATACT
+TATAGA
+TATAGC
+TATAGG
+TATAGT
+TATATA
+TATATC
+TATATG
+TATATT
+TATCAA
+TATCAC
+TATCAG
+TATCAT
+TATCCA
+TATCCC
+TATCCG
+TATCCT
+TATCGA
+TATCGC
+TATCGG
+TATCGT
+TATCTA
+TATCTC
+TATCTG
+TATCTT
+TATGAA
+TATGAC
+TATGAG
+TATGAT
+TATGCA
+TATGCC
+TATGCG
+TATGCT
+TATGGA
+TATGGC
+TATGGG
+TATGGT
+TATGTA
+TATGTC
+TATGTG
+TATGTT
+TATTAA
+TATTAC
+TATTAG
+TATTAT
+TATTCA
+TATTCC
+TATTCG
+TATTCT
+TATTGA
+TATTGC
+TATTGG
+TATTGT
+TATTTA
+TATTTC
+TATTTG
+TATTTT
+TCAAAA
+TCAAAC
+TCAAAG
+TCAAAT
+TCAACA
+TCAACC
+TCAACG
+TCAACT
+TCAAGA
+TCAAGC
+TCAAGG
+TCAAGT
+TCAATA
+TCAATC
+TCAATG
+TCAATT
+TCACAA
+TCACAC
+TCACAG
+TCACAT
+TCACCA
+TCACCC
+TCACCG
+TCACCT
+TCACGA
+TCACGC
+TCACGG
+TCACGT
+TCACTA
+TCACTC
+TCACTG
+TCACTT
+TCAGAA
+TCAGAC
+TCAGAG
+TCAGAT
+TCAGCA
+TCAGCC
+TCAGCG
+TCAGCT
+TCAGGA
+TCAGGC
+TCAGGG
+TCAGGT
+TCAGTA
+TCAGTC
+TCAGTG
+TCAGTT
+TCATAA
+TCATAC
+TCATAG
+TCATAT
+TCATCA
+TCATCC
+TCATCG
+TCATCT
+TCATGA
+TCATGC
+TCATGG
+TCATGT
+TCATTA
+TCATTC
+TCATTG
+TCATTT
+TCCAAA
+TCCAAC
+TCCAAG
+TCCAAT
+TCCACA
+TCCACC
+TCCACG
+TCCACT
+TCCAGA
+TCCAGC
+TCCAGG
+TCCAGT
+TCCATA
+TCCATC
+TCCATG
+TCCATT
+TCCCAA
+TCCCAC
+TCCCAG
+TCCCAT
+TCCCCA
+TCCCCC
+TCCCCG
+TCCCCT
+TCCCGA
+TCCCGC
+TCCCGG
+TCCCGT
+TCCCTA
+TCCCTC
+TCCCTG
+TCCCTT
+TCCGAA
+TCCGAC
+TCCGAG
+TCCGAT
+TCCGCA
+TCCGCC
+TCCGCG
+TCCGCT
+TCCGGA
+TCCGGC
+TCCGGG
+TCCGGT
+TCCGTA
+TCCGTC
+TCCGTG
+TCCGTT
+TCCTAA
+TCCTAC
+TCCTAG
+TCCTAT
+TCCTCA
+TCCTCC
+TCCTCG
+TCCTCT
+TCCTGA
+TCCTGC
+TCCTGG
+TCCTGT
+TCCTTA
+TCCTTC
+TCCTTG
+TCCTTT
+TCGAAA
+TCGAAC
+TCGAAG
+TCGAAT
+TCGACA
+TCGACC
+TCGACG
+TCGACT
+TCGAGA
+TCGAGC
+TCGAGG
+TCGAGT
+TCGATA
+TCGATC
+TCGATG
+TCGATT
+TCGCAA
+TCGCAC
+TCGCAG
+TCGCAT
+TCGCCA
+TCGCCC
+TCGCCG
+TCGCCT
+TCGCGA
+TCGCGC
+TCGCGG
+TCGCGT
+TCGCTA
+TCGCTC
+TCGCTG
+TCGCTT
+TCGGAA
+TCGGAC
+TCGGAG
+TCGGAT
+TCGGCA
+TCGGCC
+TCGGCG
+TCGGCT
+TCGGGA
+TCGGGC
+TCGGGG
+TCGGGT
+TCGGTA
+TCGGTC
+TCGGTG
+TCGGTT
+TCGTAA
+TCGTAC
+TCGTAG
+TCGTAT
+TCGTCA
+TCGTCC
+TCGTCG
+TCGTCT
+TCGTGA
+TCGTGC
+TCGTGG
+TCGTGT
+TCGTTA
+TCGTTC
+TCGTTG
+TCGTTT
+TCTAAA
+TCTAAC
+TCTAAG
+TCTAAT
+TCTACA
+TCTACC
+TCTACG
+TCTACT
+TCTAGA
+TCTAGC
+TCTAGG
+TCTAGT
+TCTATA
+TCTATC
+TCTATG
+TCTATT
+TCTCAA
+TCTCAC
+TCTCAG
+TCTCAT
+TCTCCA
+TCTCCC
+TCTCCG
+TCTCCT
+TCTCGA
+TCTCGC
+TCTCGG
+TCTCGT
+TCTCTA
+TCTCTC
+TCTCTG
+TCTCTT
+TCTGAA
+TCTGAC
+TCTGAG
+TCTGAT
+TCTGCA
+TCTGCC
+TCTGCG
+TCTGCT
+TCTGGA
+TCTGGC
+TCTGGG
+TCTGGT
+TCTGTA
+TCTGTC
+TCTGTG
+TCTGTT
+TCTTAA
+TCTTAC
+TCTTAG
+TCTTAT
+TCTTCA
+TCTTCC
+TCTTCG
+TCTTCT
+TCTTGA
+TCTTGC
+TCTTGG
+TCTTGT
+TCTTTA
+TCTTTC
+TCTTTG
+TCTTTT
+TGAAAA
+TGAAAC
+TGAAAG
+TGAAAT
+TGAACA
+TGAACC
+TGAACG
+TGAACT
+TGAAGA
+TGAAGC
+TGAAGG
+TGAAGT
+TGAATA
+TGAATC
+TGAATG
+TGAATT
+TGACAA
+TGACAC
+TGACAG
+TGACAT
+TGACCA
+TGACCC
+TGACCG
+TGACCT
+TGACGA
+TGACGC
+TGACGG
+TGACGT
+TGACTA
+TGACTC
+TGACTG
+TGACTT
+TGAGAA
+TGAGAC
+TGAGAG
+TGAGAT
+TGAGCA
+TGAGCC
+TGAGCG
+TGAGCT
+TGAGGA
+TGAGGC
+TGAGGG
+TGAGGT
+TGAGTA
+TGAGTC
+TGAGTG
+TGAGTT
+TGATAA
+TGATAC
+TGATAG
+TGATAT
+TGATCA
+TGATCC
+TGATCG
+TGATCT
+TGATGA
+TGATGC
+TGATGG
+TGATGT
+TGATTA
+TGATTC
+TGATTG
+TGATTT
+TGCAAA
+TGCAAC
+TGCAAG
+TGCAAT
+TGCACA
+TGCACC
+TGCACG
+TGCACT
+TGCAGA
+TGCAGC
+TGCAGG
+TGCAGT
+TGCATA
+TGCATC
+TGCATG
+TGCATT
+TGCCAA
+TGCCAC
+TGCCAG
+TGCCAT
+TGCCCA
+TGCCCC
+TGCCCG
+TGCCCT
+TGCCGA
+TGCCGC
+TGCCGG
+TGCCGT
+TGCCTA
+TGCCTC
+TGCCTG
+TGCCTT
+TGCGAA
+TGCGAC
+TGCGAG
+TGCGAT
+TGCGCA
+TGCGCC
+TGCGCG
+TGCGCT
+TGCGGA
+TGCGGC
+TGCGGG
+TGCGGT
+TGCGTA
+TGCGTC
+TGCGTG
+TGCGTT
+TGCTAA
+TGCTAC
+TGCTAG
+TGCTAT
+TGCTCA
+TGCTCC
+TGCTCG
+TGCTCT
+TGCTGA
+TGCTGC
+TGCTGG
+TGCTGT
+TGCTTA
+TGCTTC
+TGCTTG
+TGCTTT
+TGGAAA
+TGGAAC
+TGGAAG
+TGGAAT
+TGGACA
+TGGACC
+TGGACG
+TGGACT
+TGGAGA
+TGGAGC
+TGGAGG
+TGGAGT
+TGGATA
+TGGATC
+TGGATG
+TGGATT
+TGGCAA
+TGGCAC
+TGGCAG
+TGGCAT
+TGGCCA
+TGGCCC
+TGGCCG
+TGGCCT
+TGGCGA
+TGGCGC
+TGGCGG
+TGGCGT
+TGGCTA
+TGGCTC
+TGGCTG
+TGGCTT
+TGGGAA
+TGGGAC
+TGGGAG
+TGGGAT
+TGGGCA
+TGGGCC
+TGGGCG
+TGGGCT
+TGGGGA
+TGGGGC
+TGGGGG
+TGGGGT
+TGGGTA
+TGGGTC
+TGGGTG
+TGGGTT
+TGGTAA
+TGGTAC
+TGGTAG
+TGGTAT
+TGGTCA
+TGGTCC
+TGGTCG
+TGGTCT
+TGGTGA
+TGGTGC
+TGGTGG
+TGGTGT
+TGGTTA
+TGGTTC
+TGGTTG
+TGGTTT
+TGTAAA
+TGTAAC
+TGTAAG
+TGTAAT
+TGTACA
+TGTACC
+TGTACG
+TGTACT
+TGTAGA
+TGTAGC
+TGTAGG
+TGTAGT
+TGTATA
+TGTATC
+TGTATG
+TGTATT
+TGTCAA
+TGTCAC
+TGTCAG
+TGTCAT
+TGTCCA
+TGTCCC
+TGTCCG
+TGTCCT
+TGTCGA
+TGTCGC
+TGTCGG
+TGTCGT
+TGTCTA
+TGTCTC
+TGTCTG
+TGTCTT
+TGTGAA
+TGTGAC
+TGTGAG
+TGTGAT
+TGTGCA
+TGTGCC
+TGTGCG
+TGTGCT
+TGTGGA
+TGTGGC
+TGTGGG
+TGTGGT
+TGTGTA
+TGTGTC
+TGTGTG
+TGTGTT
+TGTTAA
+TGTTAC
+TGTTAG
+TGTTAT
+TGTTCA
+TGTTCC
+TGTTCG
+TGTTCT
+TGTTGA
+TGTTGC
+TGTTGG
+TGTTGT
+TGTTTA
+TGTTTC
+TGTTTG
+TGTTTT
+TTAAAA
+TTAAAC
+TTAAAG
+TTAAAT
+TTAACA
+TTAACC
+TTAACG
+TTAACT
+TTAAGA
+TTAAGC
+TTAAGG
+TTAAGT
+TTAATA
+TTAATC
+TTAATG
+TTAATT
+TTACAA
+TTACAC
+TTACAG
+TTACAT
+TTACCA
+TTACCC
+TTACCG
+TTACCT
+TTACGA
+TTACGC
+TTACGG
+TTACGT
+TTACTA
+TTACTC
+TTACTG
+TTACTT
+TTAGAA
+TTAGAC
+TTAGAG
+TTAGAT
+TTAGCA
+TTAGCC
+TTAGCG
+TTAGCT
+TTAGGA
+TTAGGC
+TTAGGG
+TTAGGT
+TTAGTA
+TTAGTC
+TTAGTG
+TTAGTT
+TTATAA
+TTATAC
+TTATAG
+TTATAT
+TTATCA
+TTATCC
+TTATCG
+TTATCT
+TTATGA
+TTATGC
+TTATGG
+TTATGT
+TTATTA
+TTATTC
+TTATTG
+TTATTT
+TTCAAA
+TTCAAC
+TTCAAG
+TTCAAT
+TTCACA
+TTCACC
+TTCACG
+TTCACT
+TTCAGA
+TTCAGC
+TTCAGG
+TTCAGT
+TTCATA
+TTCATC
+TTCATG
+TTCATT
+TTCCAA
+TTCCAC
+TTCCAG
+TTCCAT
+TTCCCA
+TTCCCC
+TTCCCG
+TTCCCT
+TTCCGA
+TTCCGC
+TTCCGG
+TTCCGT
+TTCCTA
+TTCCTC
+TTCCTG
+TTCCTT
+TTCGAA
+TTCGAC
+TTCGAG
+TTCGAT
+TTCGCA
+TTCGCC
+TTCGCG
+TTCGCT
+TTCGGA
+TTCGGC
+TTCGGG
+TTCGGT
+TTCGTA
+TTCGTC
+TTCGTG
+TTCGTT
+TTCTAA
+TTCTAC
+TTCTAG
+TTCTAT
+TTCTCA
+TTCTCC
+TTCTCG
+TTCTCT
+TTCTGA
+TTCTGC
+TTCTGG
+TTCTGT
+TTCTTA
+TTCTTC
+TTCTTG
+TTCTTT
+TTGAAA
+TTGAAC
+TTGAAG
+TTGAAT
+TTGACA
+TTGACC
+TTGACG
+TTGACT
+TTGAGA
+TTGAGC
+TTGAGG
+TTGAGT
+TTGATA
+TTGATC
+TTGATG
+TTGATT
+TTGCAA
+TTGCAC
+TTGCAG
+TTGCAT
+TTGCCA
+TTGCCC
+TTGCCG
+TTGCCT
+TTGCGA
+TTGCGC
+TTGCGG
+TTGCGT
+TTGCTA
+TTGCTC
+TTGCTG
+TTGCTT
+TTGGAA
+TTGGAC
+TTGGAG
+TTGGAT
+TTGGCA
+TTGGCC
+TTGGCG
+TTGGCT
+TTGGGA
+TTGGGC
+TTGGGG
+TTGGGT
+TTGGTA
+TTGGTC
+TTGGTG
+TTGGTT
+TTGTAA
+TTGTAC
+TTGTAG
+TTGTAT
+TTGTCA
+TTGTCC
+TTGTCG
+TTGTCT
+TTGTGA
+TTGTGC
+TTGTGG
+TTGTGT
+TTGTTA
+TTGTTC
+TTGTTG
+TTGTTT
+TTTAAA
+TTTAAC
+TTTAAG
+TTTAAT
+TTTACA
+TTTACC
+TTTACG
+TTTACT
+TTTAGA
+TTTAGC
+TTTAGG
+TTTAGT
+TTTATA
+TTTATC
+TTTATG
+TTTATT
+TTTCAA
+TTTCAC
+TTTCAG
+TTTCAT
+TTTCCA
+TTTCCC
+TTTCCG
+TTTCCT
+TTTCGA
+TTTCGC
+TTTCGG
+TTTCGT
+TTTCTA
+TTTCTC
+TTTCTG
+TTTCTT
+TTTGAA
+TTTGAC
+TTTGAG
+TTTGAT
+TTTGCA
+TTTGCC
+TTTGCG
+TTTGCT
+TTTGGA
+TTTGGC
+TTTGGG
+TTTGGT
+TTTGTA
+TTTGTC
+TTTGTG
+TTTGTT
+TTTTAA
+TTTTAC
+TTTTAG
+TTTTAT
+TTTTCA
+TTTTCC
+TTTTCG
+TTTTCT
+TTTTGA
+TTTTGC
+TTTTGG
+TTTTGT
+TTTTTA
+TTTTTC
+TTTTTG
+TTTTTT