Tokenizer base

config_utils.py

@@ -0,0 +1,443 @@
+# Config utils
+import yaml
+import pathlib
+from os.path import join
+import os
+import numpy as np
+import torch
+from multiprocessing import cpu_count
+
+class BaseConfig:
+    """Base class for managing and validating configurations."""
+
+    numpy_dtype_mapping = {1: np.int8,
+                           2: np.int16,
+                           8: np.int64,
+                           4: np.int32}
+
+    def __init__(self):
+        super().__init__()
+
+    def cast_to_expected_type(self, parameter_class: str, parameter_name: str, value: any) -> any:
+        """
+        Cast the given value to the expected type.
+
+        :param parameter_class: The class/category of the parameter.
+        :type parameter_class: str
+        :param parameter_name: The name of the parameter.
+        :type parameter_name: str
+        :param value: The value to be casted.
+        :type value: any
+        :return: Value casted to the expected type.
+        :rtype: any
+        :raises ValueError: If casting fails.
+        """
+        expected_type = self.parameters[parameter_class][parameter_name]['type']
+
+        if expected_type in ["integer", "int"]:
+            try:
+                return int(value)
+            except ValueError:
+                raise ValueError(f"Failed to cast value '{value}' to integer for parameter '{parameter_name}' in class '{parameter_class}'.")
+        elif expected_type == "float":
+            try:
+                return float(value)
+            except ValueError:
+                raise ValueError(f"Failed to cast value '{value}' to float for parameter '{parameter_name}' in class '{parameter_class}'.")
+        elif expected_type in ["string", "str"]:
+            return str(value)
+        elif expected_type in ["boolean", "bool"]:
+            if isinstance(value, bool):
+                return value
+            elif str(value).lower() == "true":
+                return True
+            elif str(value).lower() == "false":
+                return False
+            else:
+                raise ValueError(f"Failed to cast value '{value}' to boolean for parameter '{parameter_name}' in class '{parameter_class}'.")
+        elif expected_type == "type":
+            # For this type, we will simply return the value without casting. 
+            # It assumes the configuration provides valid Python types.
+            return value
+        elif expected_type == "list":
+            if isinstance(value, list):
+                return value
+            else:
+                raise ValueError(f"Failed to validate value '{value}' as a list for parameter '{parameter_name}' in class '{parameter_class}'.")
+        elif expected_type == "tuple":
+            if isinstance(value, tuple):
+                return value
+            else:
+                raise ValueError(f"Failed to validate value '{value}' as a tuple for parameter '{parameter_name}' in class '{parameter_class}'.")
+        elif expected_type == "set":
+            if isinstance(value, set):
+                return value
+            else:
+                raise ValueError(f"Failed to validate value '{value}' as a set for parameter '{parameter_name}' in class '{parameter_class}'.")
+        elif expected_type == "dict":
+            if isinstance(value, dict):
+                return value
+            else:
+                raise ValueError(f"Failed to validate value '{value}' as a dict for parameter '{parameter_name}' in class '{parameter_class}'.")
+        else:
+            raise ValueError(f"Unknown expected type '{expected_type}' for parameter '{parameter_name}' in class '{parameter_class}'.")
+
+
+
+    def get_parameter(self, parameter_class: str, parameter_name: str) -> any:
+        """
+        Retrieve the default value of a specified parameter.
+
+        :param parameter_class: The class/category of the parameter (e.g., 'segmentation').
+        :type parameter_class: str
+        :param parameter_name: The name of the parameter.
+        :type parameter_name: str
+        :return: Default value of the parameter, casted to the expected type.
+        :rtype: any
+        """
+        default_value = self.parameters[parameter_class][parameter_name]['default']
+        return self.cast_to_expected_type(parameter_class, parameter_name, default_value)
+    
+
+    
+    def validate_type(self, parameter_class: str, parameter_name: str, value: any) -> bool:
+        """
+        Validate the type of a given value against the expected type.
+
+        :param parameter_class: The class/category of the parameter.
+        :type parameter_class: str
+        :param parameter_name: The name of the parameter.
+        :type parameter_name: str
+        :param value: The value to be validated.
+        :type value: any
+        :return: True if the value is of the expected type, otherwise False.
+        :rtype: bool
+        """
+        expected_type = self.parameters[parameter_class][parameter_name]['type']
+
+        if expected_type == "integer" and not isinstance(value, int):
+            return False
+        elif expected_type == "float" and not isinstance(value, float):
+            return False
+        elif expected_type == "string" and not isinstance(value, str):
+            return False
+        else:
+            return True
+    
+    def validate_value(self, parameter_class: str, parameter_name: str, value: any) -> bool:
+        """
+        Validate the value of a parameter against its constraints.
+
+        :param parameter_class: The class/category of the parameter.
+        :type parameter_class: str
+        :param parameter_name: The name of the parameter.
+        :type parameter_name: str
+        :param value: The value to be validated.
+        :type value: any
+        :return: True if the value meets the constraints, otherwise False.
+        :rtype: bool
+        """
+        constraints = self.parameters[parameter_class][parameter_name].get('constraints', {})
+        
+        if 'options' in constraints and value not in constraints['options']:
+            return False
+        if 'min' in constraints and value < constraints['min']:
+            return False
+        if 'max' in constraints and value > constraints['max']:
+            return False
+        return True
+    
+
+    def validate(self, parameter_class: str, parameter_name: str, value: any):
+        """
+        Validate both the type and value of a parameter.
+
+        :param parameter_class: The class/category of the parameter.
+        :type parameter_class: str
+        :param parameter_name: The name of the parameter.
+        :type parameter_name: str
+        :param value: The value to be validated.
+        :type value: any
+        :raises TypeError: If the value is not of the expected type.
+        :raises ValueError: If the value does not meet the parameter's constraints.
+        """
+        if not self.validate_type(parameter_class, parameter_name, value):
+            raise TypeError(f"Invalid type for {parameter_name} for parameter class '{parameter_class}'. Expected {self.parameters[parameter_class][parameter_name]['type']}.")
+        
+        if not self.validate_value(parameter_class, parameter_name, value):
+            raise ValueError(f"Invalid value for {parameter_name}  for parameter class '{parameter_class}'. Constraints: {self.parameters[parameter_class][parameter_name].get('constraints', {})}.")
+
+    def describe(self, parameter_class: str, parameter_name: str) -> str:
+        """
+        Retrieve the description of a parameter.
+
+        :param parameter_class: The class/category of the parameter.
+        :type parameter_class: str
+        :param parameter_name: The name of the parameter.
+        :type parameter_name: str
+        :return: Description of the parameter.
+        :rtype: str
+        """
+        return self.parameters[parameter_class][parameter_name]['description']
+
+
+
+class SeqConfig(BaseConfig):
+    """Class to manage and validate sequence processing configurations."""
+
+    def __init__(self):
+        super().__init__()
+        self.default_seq_config_file = self._get_default_sequence_processing_config_file()
+        with open(self.default_seq_config_file, 'r') as file:
+            self.parameters = yaml.safe_load(file)
+
+        # Some postprocessing steps
+        self.parameters['tokenization']['shift']['constraints']['max'] = self.parameters['tokenization']['kmer']['default']-1
+        # Ha valaki update-li a k-mer paramter-t, akkor triggerelni kellene, hogy mi legyen. 
+
+        self.get_and_set_segmentation_parameters()
+        self.get_and_set_tokenization_parameters()
+        self.get_and_set_computational_parameters()
+
+    def _get_default_sequence_processing_config_file(self) -> str:
+        """
+        Retrieve the default sequence processing configuration file.
+
+        :return: Path to the configuration file.
+        :rtype: str
+        """
+        current_path = pathlib.Path(__file__).parent
+        prokbert_seq_config_file = join(current_path, 'configs', 'sequence_processing.yaml')
+        self.current_path = current_path
+
+        try:
+            # Attempt to read the environment variable
+            prokbert_seq_config_file = os.environ['SEQ_CONFIG_FILE']
+        except KeyError:
+            # Handle the case when the environment variable is not found
+            print("SEQ_CONFIG_FILE environment variable has not been set. Using default value: {0}".format(prokbert_seq_config_file))
+        return prokbert_seq_config_file
+
+    
+    def get_and_set_segmentation_parameters(self, parameters: dict = {}) -> dict:
+        """
+        Retrieve and validate the provided parameters for segmentation.
+
+        :param parameters: A dictionary of parameters to be validated.
+        :type parameters: dict
+        :return: A dictionary of validated segmentation parameters.
+        :rtype: dict
+        :raises ValueError: If an invalid segmentation parameter is provided.
+        """
+        segmentation_params = {k: self.get_parameter('segmentation', k) for k in self.parameters['segmentation']}
+
+        for param, param_value in parameters.items():
+            if param not in segmentation_params:
+                raise ValueError(f"The provided {param} is an INVALID segmentation parameter! The valid parameters are: {list(segmentation_params.keys())}")
+            self.validate('segmentation', param, param_value)
+            segmentation_params[param] = param_value
+        self.segmentation_params = segmentation_params
+
+
+        return segmentation_params
+
+
+    def get_and_set_tokenization_parameters(self, parameters: dict = {}) -> dict:
+        # Updating the other parameters if necesseary, i.e. if k-mer has-been changed, then the shift is updated and we run a parameter check at the end
+
+        tokenization_params = {k: self.get_parameter('tokenization', k) for k in self.parameters['tokenization']}
+        for param, param_value in parameters.items():
+            if param not in tokenization_params:
+                raise ValueError(f"The provided {param} is an INVALID tokenization parameter! The valid parameters are: {list(tokenization_params.keys())}")
+            self.validate('tokenization', param, param_value)
+            tokenization_params[param] = param_value
+
+        # Loading and check the vocab file. It is assumed that its ordered dictionary
+        vocabfile=tokenization_params['vocabfile']
+        act_kmer = tokenization_params['kmer']
+        if vocabfile=='auto':
+            print(self.current_path)
+            vocabfile_path = join(self.current_path, 'data/prokbert_vocabs/', f'prokbert-base-dna{act_kmer}', 'vocab.txt')
+            tokenization_params['vocabfile'] = vocabfile_path
+        else:
+            vocabfile_path = vocabfile
+        with open(vocabfile_path) as vocabfile_in:
+            vocabmap = {line.strip(): i for i, line in enumerate(vocabfile_in)}
+        tokenization_params['vocabmap'] = vocabmap
+
+        # Loading the vocab
+        self.tokenization_params = tokenization_params
+        return tokenization_params    
+
+    def get_and_set_computational_parameters(self, parameters: dict = {}) -> dict:
+        """ Reading and validating the computational paramters
+        """
+
+        computational_params = {k: self.get_parameter('computation', k) for k in self.parameters['computation']}
+        core_count = cpu_count()
+
+        if computational_params['cpu_cores_for_segmentation'] == -1:
+            computational_params['cpu_cores_for_segmentation'] = core_count
+
+        if computational_params['cpu_cores_for_tokenization'] == -1:
+            computational_params['cpu_cores_for_tokenization'] = core_count
+
+        
+
+        for param, param_value in parameters.items():
+            if param not in computational_params:
+                raise ValueError(f"The provided {param} is an INVALID computation parameter! The valid parameters are: {list(computational_params.keys())}")
+            self.validate('computation', param, param_value)
+            computational_params[param] = param_value
+
+        np_tokentype= SeqConfig.numpy_dtype_mapping[computational_params['numpy_token_integer_prec_byte']]
+        computational_params['np_tokentype'] = np_tokentype
+        self.computational_params = computational_params
+        return computational_params
+
+
+    def get_maximum_segment_length_from_token_count_from_params(self):
+        """Calculating the maximum length of the segment from the token count """
+        max_token_counts = self.tokenization_params['token_limit']
+        shift = self.tokenization_params['shift']
+        kmer = self.tokenization_params['kmer']
+        return self.get_maximum_segment_length_from_token_count(max_token_counts, shift, kmer)
+
+    def get_maximum_token_count_from_max_length_from_params(self):
+        """Calculating the maximum length of the segment from the token count """
+
+
+        max_segment_length = self.tokenization_params['max_segment_length']
+        shift = self.tokenization_params['shift']
+        kmer = self.tokenization_params['kmer']          
+        max_token_count = self.get_maximum_token_count_from_max_length(max_segment_length, shift, kmer)
+
+        return max_token_count
+
+    @staticmethod
+    def get_maximum_segment_length_from_token_count(max_token_counts, shift, kmer):
+        """Calcuates how long sequence can be covered
+        """
+
+        max_segment_length = (max_token_counts-3)*shift + kmer
+        return max_segment_length
+
+    @staticmethod
+    def get_maximum_token_count_from_max_length(max_segment_length, shift, kmer):
+        """Calcuates how long sequence can be covered
+        """
+        max_token_count = int(np.ceil((max_segment_length - kmer)/shift+3))
+        return max_token_count
+
+class ProkBERTConfig(BaseConfig):
+    """Class to manage and validate pretraining configurations."""
+
+    torch_dtype_mapping = {1: torch.uint8,
+                           2: torch.int16,
+                           8: torch.int64,
+                           4: torch.int32}
+
+    def __init__(self):
+        super().__init__()
+
+        self.default_pretrain_config_file = self._get_default_pretrain_config_file()
+        with open(self.default_pretrain_config_file, 'r') as file:
+            self.parameters = yaml.safe_load(file)
+            
+        # Load and validate each parameter set
+        self.data_collator_params = self.get_set_parameters('data_collator')
+        self.model_params = self.get_set_parameters('model')
+        self.dataset_params = self.get_set_parameters('dataset')
+        self.pretraining_params = self.get_set_parameters('pretraining')
+        # Getting the sequtils params as well
+
+        self.def_seq_config = SeqConfig()
+        self.segmentation_params = self.def_seq_config.get_and_set_segmentation_parameters(self.parameters['segmentation'])
+        self.tokenization_params = self.def_seq_config.get_and_set_tokenization_parameters(self.parameters['tokenization'])
+        self.computation_params = self.def_seq_config.get_and_set_computational_parameters(self.parameters['computation'])
+
+        self.default_torchtype = ProkBERTConfig.torch_dtype_mapping[self.computation_params['numpy_token_integer_prec_byte']]
+
+    def _get_default_pretrain_config_file(self) -> str:
+        """
+        Retrieve the default pretraining configuration file.
+
+        :return: Path to the configuration file.
+        :rtype: str
+        """
+        current_path = pathlib.Path(__file__).parent
+        pretrain_config_file = join(current_path, 'configs', 'pretraining.yaml')
+
+        try:
+            # Attempt to read the environment variable
+            pretrain_config_file = os.environ['PRETRAIN_CONFIG_FILE']
+        except KeyError:
+            # Handle the case when the environment variable is not found
+            print(f"PRETRAIN_CONFIG_FILE environment variable has not been set. Using default value: {pretrain_config_file}")
+        return pretrain_config_file
+    
+    def get_set_parameters(self, parameter_class: str, parameters: dict = {}) -> dict:
+        """
+        Retrieve and validate the provided parameters for a given parameter class.
+
+        :param parameter_class: The class/category of the parameter (e.g., 'data_collator').
+        :type parameter_class: str
+        :param parameters: A dictionary of parameters to be validated.
+        :type parameters: dict
+        :return: A dictionary of validated parameters.
+        :rtype: dict
+        :raises ValueError: If an invalid parameter is provided.
+        """
+        class_params = {k: self.get_parameter(parameter_class, k) for k in self.parameters[parameter_class]}
+
+        # First validatiading the class parameters as well
+        for param, param_value in class_params.items():
+
+            self.validate(parameter_class, param, param_value)
+
+
+        for param, param_value in parameters.items():
+            if param not in class_params:
+                raise ValueError(f"The provided {param} is an INVALID {parameter_class} parameter! The valid parameters are: {list(class_params.keys())}")
+            self.validate(parameter_class, param, param_value)
+            class_params[param] = param_value
+
+        return class_params
+    
+    def get_and_set_model_parameters(self, parameters: dict = {}) -> dict:
+        """ Setting the model parameters """
+
+        self.model_params = self.get_set_parameters('model', parameters)
+
+        return self.model_params
+
+    def get_and_set_dataset_parameters(self, parameters: dict = {}) -> dict:
+        """ Setting the dataset parameters """
+
+        self.dataset_params = self.get_set_parameters('dataset', parameters)
+
+        return self.dataset_params
+
+    def get_and_set_pretraining_parameters(self, parameters: dict = {}) -> dict:
+        """ Setting the model parameters """
+        self.pretraining_params = self.get_set_parameters('pretraining', parameters)
+
+        return self.pretraining_params       
+    
+    
+    def get_and_set_datacollator_parameters(self, parameters: dict = {}) -> dict:
+        """ Setting the model parameters """
+        self.data_collator_params = self.get_set_parameters('data_collator', parameters)
+        return self.data_collator_params
+    
+    def get_and_set_segmentation_parameters(self, parameters: dict = {}) -> dict:
+        self.segmentation_params = self.def_seq_config.get_and_set_segmentation_parameters(parameters)
+
+        return self.segmentation_params 
+    def get_and_set_tokenization_parameters(self, parameters: dict = {}) -> dict:
+        self.tokenization_params = self.def_seq_config.get_and_set_tokenization_parameters(parameters)
+        
+        return self.tokenization_params 
+    def get_and_set_computation_params(self, parameters: dict = {}) -> dict:
+        self.computation_params = self.def_seq_config.get_and_set_computational_parameters(parameters)
+        return self.computation_params    

data/prokbert_vocabs/prokbert-base-dna1/vocab.txt

@@ -0,0 +1,9 @@
+[PAD]
+[UNK]
+[CLS]
+[SEP]
+[MASK]
+A
+C
+G
+T

data/prokbert_vocabs/prokbert-base-dna2/vocab.txt

@@ -0,0 +1,21 @@
+[PAD]
+[UNK]
+[CLS]
+[SEP]
+[MASK]
+AA
+AC
+AG
+AT
+CA
+CC
+CG
+CT
+GA
+GC
+GG
+GT
+TA
+TC
+TG
+TT

data/prokbert_vocabs/prokbert-base-dna3/vocab.txt

@@ -0,0 +1,69 @@
+[PAD]
+[UNK]
+[CLS]
+[SEP]
+[MASK]
+AAA
+AAC
+AAG
+AAT
+ACA
+ACC
+ACG
+ACT
+AGA
+AGC
+AGG
+AGT
+ATA
+ATC
+ATG
+ATT
+CAA
+CAC
+CAG
+CAT
+CCA
+CCC
+CCG
+CCT
+CGA
+CGC
+CGG
+CGT
+CTA
+CTC
+CTG
+CTT
+GAA
+GAC
+GAG
+GAT
+GCA
+GCC
+GCG
+GCT
+GGA
+GGC
+GGG
+GGT
+GTA
+GTC
+GTG
+GTT
+TAA
+TAC
+TAG
+TAT
+TCA
+TCC
+TCG
+TCT
+TGA
+TGC
+TGG
+TGT
+TTA
+TTC
+TTG
+TTT

data/prokbert_vocabs/prokbert-base-dna4/vocab.txt

@@ -0,0 +1,261 @@
+[PAD]
+[UNK]
+[CLS]
+[SEP]
+[MASK]
+AAAA
+AAAC
+AAAG
+AAAT
+AACA
+AACC
+AACG
+AACT
+AAGA
+AAGC
+AAGG
+AAGT
+AATA
+AATC
+AATG
+AATT
+ACAA
+ACAC
+ACAG
+ACAT
+ACCA
+ACCC
+ACCG
+ACCT
+ACGA
+ACGC
+ACGG
+ACGT
+ACTA
+ACTC
+ACTG
+ACTT
+AGAA
+AGAC
+AGAG
+AGAT
+AGCA
+AGCC
+AGCG
+AGCT
+AGGA
+AGGC
+AGGG
+AGGT
+AGTA
+AGTC
+AGTG
+AGTT
+ATAA
+ATAC
+ATAG
+ATAT
+ATCA
+ATCC
+ATCG
+ATCT
+ATGA
+ATGC
+ATGG
+ATGT
+ATTA
+ATTC
+ATTG
+ATTT
+CAAA
+CAAC
+CAAG
+CAAT
+CACA
+CACC
+CACG
+CACT
+CAGA
+CAGC
+CAGG
+CAGT
+CATA
+CATC
+CATG
+CATT
+CCAA
+CCAC
+CCAG
+CCAT
+CCCA
+CCCC
+CCCG
+CCCT
+CCGA
+CCGC
+CCGG
+CCGT
+CCTA
+CCTC
+CCTG
+CCTT
+CGAA
+CGAC
+CGAG
+CGAT
+CGCA
+CGCC
+CGCG
+CGCT
+CGGA
+CGGC
+CGGG
+CGGT
+CGTA
+CGTC
+CGTG
+CGTT
+CTAA
+CTAC
+CTAG
+CTAT
+CTCA
+CTCC
+CTCG
+CTCT
+CTGA
+CTGC
+CTGG
+CTGT
+CTTA
+CTTC
+CTTG
+CTTT
+GAAA
+GAAC
+GAAG
+GAAT
+GACA
+GACC
+GACG
+GACT
+GAGA
+GAGC
+GAGG
+GAGT
+GATA
+GATC
+GATG
+GATT
+GCAA
+GCAC
+GCAG
+GCAT
+GCCA
+GCCC
+GCCG
+GCCT
+GCGA
+GCGC
+GCGG
+GCGT
+GCTA
+GCTC
+GCTG
+GCTT
+GGAA
+GGAC
+GGAG
+GGAT
+GGCA
+GGCC
+GGCG
+GGCT
+GGGA
+GGGC
+GGGG
+GGGT
+GGTA
+GGTC
+GGTG
+GGTT
+GTAA
+GTAC
+GTAG
+GTAT
+GTCA
+GTCC
+GTCG
+GTCT
+GTGA
+GTGC
+GTGG
+GTGT
+GTTA
+GTTC
+GTTG
+GTTT
+TAAA
+TAAC
+TAAG
+TAAT
+TACA
+TACC
+TACG
+TACT
+TAGA
+TAGC
+TAGG
+TAGT
+TATA
+TATC
+TATG
+TATT
+TCAA
+TCAC
+TCAG
+TCAT
+TCCA
+TCCC
+TCCG
+TCCT
+TCGA
+TCGC
+TCGG
+TCGT
+TCTA
+TCTC
+TCTG
+TCTT
+TGAA
+TGAC
+TGAG
+TGAT
+TGCA
+TGCC
+TGCG
+TGCT
+TGGA
+TGGC
+TGGG
+TGGT
+TGTA
+TGTC
+TGTG
+TGTT
+TTAA
+TTAC
+TTAG
+TTAT
+TTCA
+TTCC
+TTCG
+TTCT
+TTGA
+TTGC
+TTGG
+TTGT
+TTTA
+TTTC
+TTTG
+TTTT

data/prokbert_vocabs/prokbert-base-dna5/vocab.txt

@@ -0,0 +1,1029 @@
+[PAD]
+[UNK]
+[CLS]
+[SEP]
+[MASK]
+AAAAA
+AAAAC
+AAAAG
+AAAAT
+AAACA
+AAACC
+AAACG
+AAACT
+AAAGA
+AAAGC
+AAAGG
+AAAGT
+AAATA
+AAATC
+AAATG
+AAATT
+AACAA
+AACAC
+AACAG
+AACAT
+AACCA
+AACCC
+AACCG
+AACCT
+AACGA
+AACGC
+AACGG
+AACGT
+AACTA
+AACTC
+AACTG
+AACTT
+AAGAA
+AAGAC
+AAGAG
+AAGAT
+AAGCA
+AAGCC
+AAGCG
+AAGCT
+AAGGA
+AAGGC
+AAGGG
+AAGGT
+AAGTA
+AAGTC
+AAGTG
+AAGTT
+AATAA
+AATAC
+AATAG
+AATAT
+AATCA
+AATCC
+AATCG
+AATCT
+AATGA
+AATGC
+AATGG
+AATGT
+AATTA
+AATTC
+AATTG
+AATTT
+ACAAA
+ACAAC
+ACAAG
+ACAAT
+ACACA
+ACACC
+ACACG
+ACACT
+ACAGA
+ACAGC
+ACAGG
+ACAGT
+ACATA
+ACATC
+ACATG
+ACATT
+ACCAA
+ACCAC
+ACCAG
+ACCAT
+ACCCA
+ACCCC
+ACCCG
+ACCCT
+ACCGA
+ACCGC
+ACCGG
+ACCGT
+ACCTA
+ACCTC
+ACCTG
+ACCTT
+ACGAA
+ACGAC
+ACGAG
+ACGAT
+ACGCA
+ACGCC
+ACGCG
+ACGCT
+ACGGA
+ACGGC
+ACGGG
+ACGGT
+ACGTA
+ACGTC
+ACGTG
+ACGTT
+ACTAA
+ACTAC
+ACTAG
+ACTAT
+ACTCA
+ACTCC
+ACTCG
+ACTCT
+ACTGA
+ACTGC
+ACTGG
+ACTGT
+ACTTA
+ACTTC
+ACTTG
+ACTTT
+AGAAA
+AGAAC
+AGAAG
+AGAAT
+AGACA
+AGACC
+AGACG
+AGACT
+AGAGA
+AGAGC
+AGAGG
+AGAGT
+AGATA
+AGATC
+AGATG
+AGATT
+AGCAA
+AGCAC
+AGCAG
+AGCAT
+AGCCA
+AGCCC
+AGCCG
+AGCCT
+AGCGA
+AGCGC
+AGCGG
+AGCGT
+AGCTA
+AGCTC
+AGCTG
+AGCTT
+AGGAA
+AGGAC
+AGGAG
+AGGAT
+AGGCA
+AGGCC
+AGGCG
+AGGCT
+AGGGA
+AGGGC
+AGGGG
+AGGGT
+AGGTA
+AGGTC
+AGGTG
+AGGTT
+AGTAA
+AGTAC
+AGTAG
+AGTAT
+AGTCA
+AGTCC
+AGTCG
+AGTCT
+AGTGA
+AGTGC
+AGTGG
+AGTGT
+AGTTA
+AGTTC
+AGTTG
+AGTTT
+ATAAA
+ATAAC
+ATAAG
+ATAAT
+ATACA
+ATACC
+ATACG
+ATACT
+ATAGA
+ATAGC
+ATAGG
+ATAGT
+ATATA
+ATATC
+ATATG
+ATATT
+ATCAA
+ATCAC
+ATCAG
+ATCAT
+ATCCA
+ATCCC
+ATCCG
+ATCCT
+ATCGA
+ATCGC
+ATCGG
+ATCGT
+ATCTA
+ATCTC
+ATCTG
+ATCTT
+ATGAA
+ATGAC
+ATGAG
+ATGAT
+ATGCA
+ATGCC
+ATGCG
+ATGCT
+ATGGA
+ATGGC
+ATGGG
+ATGGT
+ATGTA
+ATGTC
+ATGTG
+ATGTT
+ATTAA
+ATTAC
+ATTAG
+ATTAT
+ATTCA
+ATTCC
+ATTCG
+ATTCT
+ATTGA
+ATTGC
+ATTGG
+ATTGT
+ATTTA
+ATTTC
+ATTTG
+ATTTT
+CAAAA
+CAAAC
+CAAAG
+CAAAT
+CAACA
+CAACC
+CAACG
+CAACT
+CAAGA
+CAAGC
+CAAGG
+CAAGT
+CAATA
+CAATC
+CAATG
+CAATT
+CACAA
+CACAC
+CACAG
+CACAT
+CACCA
+CACCC
+CACCG
+CACCT
+CACGA
+CACGC
+CACGG
+CACGT
+CACTA
+CACTC
+CACTG
+CACTT
+CAGAA
+CAGAC
+CAGAG
+CAGAT
+CAGCA
+CAGCC
+CAGCG
+CAGCT
+CAGGA
+CAGGC
+CAGGG
+CAGGT
+CAGTA
+CAGTC
+CAGTG
+CAGTT
+CATAA
+CATAC
+CATAG
+CATAT
+CATCA
+CATCC
+CATCG
+CATCT
+CATGA
+CATGC
+CATGG
+CATGT
+CATTA
+CATTC
+CATTG
+CATTT
+CCAAA
+CCAAC
+CCAAG
+CCAAT
+CCACA
+CCACC
+CCACG
+CCACT
+CCAGA
+CCAGC
+CCAGG
+CCAGT
+CCATA
+CCATC
+CCATG
+CCATT
+CCCAA
+CCCAC
+CCCAG
+CCCAT
+CCCCA
+CCCCC
+CCCCG
+CCCCT
+CCCGA
+CCCGC
+CCCGG
+CCCGT
+CCCTA
+CCCTC
+CCCTG
+CCCTT
+CCGAA
+CCGAC
+CCGAG
+CCGAT
+CCGCA
+CCGCC
+CCGCG
+CCGCT
+CCGGA
+CCGGC
+CCGGG
+CCGGT
+CCGTA
+CCGTC
+CCGTG
+CCGTT
+CCTAA
+CCTAC
+CCTAG
+CCTAT
+CCTCA
+CCTCC
+CCTCG
+CCTCT
+CCTGA
+CCTGC
+CCTGG
+CCTGT
+CCTTA
+CCTTC
+CCTTG
+CCTTT
+CGAAA
+CGAAC
+CGAAG
+CGAAT
+CGACA
+CGACC
+CGACG
+CGACT
+CGAGA
+CGAGC
+CGAGG
+CGAGT
+CGATA
+CGATC
+CGATG
+CGATT
+CGCAA
+CGCAC
+CGCAG
+CGCAT
+CGCCA
+CGCCC
+CGCCG
+CGCCT
+CGCGA
+CGCGC
+CGCGG
+CGCGT
+CGCTA
+CGCTC
+CGCTG
+CGCTT
+CGGAA
+CGGAC
+CGGAG
+CGGAT
+CGGCA
+CGGCC
+CGGCG
+CGGCT
+CGGGA
+CGGGC
+CGGGG
+CGGGT
+CGGTA
+CGGTC
+CGGTG
+CGGTT
+CGTAA
+CGTAC
+CGTAG
+CGTAT
+CGTCA
+CGTCC
+CGTCG
+CGTCT
+CGTGA
+CGTGC
+CGTGG
+CGTGT
+CGTTA
+CGTTC
+CGTTG
+CGTTT
+CTAAA
+CTAAC
+CTAAG
+CTAAT
+CTACA
+CTACC
+CTACG
+CTACT
+CTAGA
+CTAGC
+CTAGG
+CTAGT
+CTATA
+CTATC
+CTATG
+CTATT
+CTCAA
+CTCAC
+CTCAG
+CTCAT
+CTCCA
+CTCCC
+CTCCG
+CTCCT
+CTCGA
+CTCGC
+CTCGG
+CTCGT
+CTCTA
+CTCTC
+CTCTG
+CTCTT
+CTGAA
+CTGAC
+CTGAG
+CTGAT
+CTGCA
+CTGCC
+CTGCG
+CTGCT
+CTGGA
+CTGGC
+CTGGG
+CTGGT
+CTGTA
+CTGTC
+CTGTG
+CTGTT
+CTTAA
+CTTAC
+CTTAG
+CTTAT
+CTTCA
+CTTCC
+CTTCG
+CTTCT
+CTTGA
+CTTGC
+CTTGG
+CTTGT
+CTTTA
+CTTTC
+CTTTG
+CTTTT
+GAAAA
+GAAAC
+GAAAG
+GAAAT
+GAACA
+GAACC
+GAACG
+GAACT
+GAAGA
+GAAGC
+GAAGG
+GAAGT
+GAATA
+GAATC
+GAATG
+GAATT
+GACAA
+GACAC
+GACAG
+GACAT
+GACCA
+GACCC
+GACCG
+GACCT
+GACGA
+GACGC
+GACGG
+GACGT
+GACTA
+GACTC
+GACTG
+GACTT
+GAGAA
+GAGAC
+GAGAG
+GAGAT
+GAGCA
+GAGCC
+GAGCG
+GAGCT
+GAGGA
+GAGGC
+GAGGG
+GAGGT
+GAGTA
+GAGTC
+GAGTG
+GAGTT
+GATAA
+GATAC
+GATAG
+GATAT
+GATCA
+GATCC
+GATCG
+GATCT
+GATGA
+GATGC
+GATGG
+GATGT
+GATTA
+GATTC
+GATTG
+GATTT
+GCAAA
+GCAAC
+GCAAG
+GCAAT
+GCACA
+GCACC
+GCACG
+GCACT
+GCAGA
+GCAGC
+GCAGG
+GCAGT
+GCATA
+GCATC
+GCATG
+GCATT
+GCCAA
+GCCAC
+GCCAG
+GCCAT
+GCCCA
+GCCCC
+GCCCG
+GCCCT
+GCCGA
+GCCGC
+GCCGG
+GCCGT
+GCCTA
+GCCTC
+GCCTG
+GCCTT
+GCGAA
+GCGAC
+GCGAG
+GCGAT
+GCGCA
+GCGCC
+GCGCG
+GCGCT
+GCGGA
+GCGGC
+GCGGG
+GCGGT
+GCGTA
+GCGTC
+GCGTG
+GCGTT
+GCTAA
+GCTAC
+GCTAG
+GCTAT
+GCTCA
+GCTCC
+GCTCG
+GCTCT
+GCTGA
+GCTGC
+GCTGG
+GCTGT
+GCTTA
+GCTTC
+GCTTG
+GCTTT
+GGAAA
+GGAAC
+GGAAG
+GGAAT
+GGACA
+GGACC
+GGACG
+GGACT
+GGAGA
+GGAGC
+GGAGG
+GGAGT
+GGATA
+GGATC
+GGATG
+GGATT
+GGCAA
+GGCAC
+GGCAG
+GGCAT
+GGCCA
+GGCCC
+GGCCG
+GGCCT
+GGCGA
+GGCGC
+GGCGG
+GGCGT
+GGCTA
+GGCTC
+GGCTG
+GGCTT
+GGGAA
+GGGAC
+GGGAG
+GGGAT
+GGGCA
+GGGCC
+GGGCG
+GGGCT
+GGGGA
+GGGGC
+GGGGG
+GGGGT
+GGGTA
+GGGTC
+GGGTG
+GGGTT
+GGTAA
+GGTAC
+GGTAG
+GGTAT
+GGTCA
+GGTCC
+GGTCG
+GGTCT
+GGTGA
+GGTGC
+GGTGG
+GGTGT
+GGTTA
+GGTTC
+GGTTG
+GGTTT
+GTAAA
+GTAAC
+GTAAG
+GTAAT
+GTACA
+GTACC
+GTACG
+GTACT
+GTAGA
+GTAGC
+GTAGG
+GTAGT
+GTATA
+GTATC
+GTATG
+GTATT
+GTCAA
+GTCAC
+GTCAG
+GTCAT
+GTCCA
+GTCCC
+GTCCG
+GTCCT
+GTCGA
+GTCGC
+GTCGG
+GTCGT
+GTCTA
+GTCTC
+GTCTG
+GTCTT
+GTGAA
+GTGAC
+GTGAG
+GTGAT
+GTGCA
+GTGCC
+GTGCG
+GTGCT
+GTGGA
+GTGGC
+GTGGG
+GTGGT
+GTGTA
+GTGTC
+GTGTG
+GTGTT
+GTTAA
+GTTAC
+GTTAG
+GTTAT
+GTTCA
+GTTCC
+GTTCG
+GTTCT
+GTTGA
+GTTGC
+GTTGG
+GTTGT
+GTTTA
+GTTTC
+GTTTG
+GTTTT
+TAAAA
+TAAAC
+TAAAG
+TAAAT
+TAACA
+TAACC
+TAACG
+TAACT
+TAAGA
+TAAGC
+TAAGG
+TAAGT
+TAATA
+TAATC
+TAATG
+TAATT
+TACAA
+TACAC
+TACAG
+TACAT
+TACCA
+TACCC
+TACCG
+TACCT
+TACGA
+TACGC
+TACGG
+TACGT
+TACTA
+TACTC
+TACTG
+TACTT
+TAGAA
+TAGAC
+TAGAG
+TAGAT
+TAGCA
+TAGCC
+TAGCG
+TAGCT
+TAGGA
+TAGGC
+TAGGG
+TAGGT
+TAGTA
+TAGTC
+TAGTG
+TAGTT
+TATAA
+TATAC
+TATAG
+TATAT
+TATCA
+TATCC
+TATCG
+TATCT
+TATGA
+TATGC
+TATGG
+TATGT
+TATTA
+TATTC
+TATTG
+TATTT
+TCAAA
+TCAAC
+TCAAG
+TCAAT
+TCACA
+TCACC
+TCACG
+TCACT
+TCAGA
+TCAGC
+TCAGG
+TCAGT
+TCATA
+TCATC
+TCATG
+TCATT
+TCCAA
+TCCAC
+TCCAG
+TCCAT
+TCCCA
+TCCCC
+TCCCG
+TCCCT
+TCCGA
+TCCGC
+TCCGG
+TCCGT
+TCCTA
+TCCTC
+TCCTG
+TCCTT
+TCGAA
+TCGAC
+TCGAG
+TCGAT
+TCGCA
+TCGCC
+TCGCG
+TCGCT
+TCGGA
+TCGGC
+TCGGG
+TCGGT
+TCGTA
+TCGTC
+TCGTG
+TCGTT
+TCTAA
+TCTAC
+TCTAG
+TCTAT
+TCTCA
+TCTCC
+TCTCG
+TCTCT
+TCTGA
+TCTGC
+TCTGG
+TCTGT
+TCTTA
+TCTTC
+TCTTG
+TCTTT
+TGAAA
+TGAAC
+TGAAG
+TGAAT
+TGACA
+TGACC
+TGACG
+TGACT
+TGAGA
+TGAGC
+TGAGG
+TGAGT
+TGATA
+TGATC
+TGATG
+TGATT
+TGCAA
+TGCAC
+TGCAG
+TGCAT
+TGCCA
+TGCCC
+TGCCG
+TGCCT
+TGCGA
+TGCGC
+TGCGG
+TGCGT
+TGCTA
+TGCTC
+TGCTG
+TGCTT
+TGGAA
+TGGAC
+TGGAG
+TGGAT
+TGGCA
+TGGCC
+TGGCG
+TGGCT
+TGGGA
+TGGGC
+TGGGG
+TGGGT
+TGGTA
+TGGTC
+TGGTG
+TGGTT
+TGTAA
+TGTAC
+TGTAG
+TGTAT
+TGTCA
+TGTCC
+TGTCG
+TGTCT
+TGTGA
+TGTGC
+TGTGG
+TGTGT
+TGTTA
+TGTTC
+TGTTG
+TGTTT
+TTAAA
+TTAAC
+TTAAG
+TTAAT
+TTACA
+TTACC
+TTACG
+TTACT
+TTAGA
+TTAGC
+TTAGG
+TTAGT
+TTATA
+TTATC
+TTATG
+TTATT
+TTCAA
+TTCAC
+TTCAG
+TTCAT
+TTCCA
+TTCCC
+TTCCG
+TTCCT
+TTCGA
+TTCGC
+TTCGG
+TTCGT
+TTCTA
+TTCTC
+TTCTG
+TTCTT
+TTGAA
+TTGAC
+TTGAG
+TTGAT
+TTGCA
+TTGCC
+TTGCG
+TTGCT
+TTGGA
+TTGGC
+TTGGG
+TTGGT
+TTGTA
+TTGTC
+TTGTG
+TTGTT
+TTTAA
+TTTAC
+TTTAG
+TTTAT
+TTTCA
+TTTCC
+TTTCG
+TTTCT
+TTTGA
+TTTGC
+TTTGG
+TTTGT
+TTTTA
+TTTTC
+TTTTG
+TTTTT

data/prokbert_vocabs/prokbert-base-dna6/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

general_utils.py

@@ -0,0 +1,304 @@
+# coding=utf-8
+
+import pandas as pd
+import os
+import numpy as np
+import subprocess
+import shutil
+""" Library for general utils, such as dataframe properties checking,
+creating directories, checking files, etc.
+"""
+
+
+def check_expected_columns(df: pd.DataFrame, expected_columns: list) -> bool:
+    """
+    Checks if a DataFrame contains the expected columns.
+    
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The input DataFrame to be checked.
+    expected_columns : list
+        A list of columns that are expected to be present in the DataFrame.
+        
+    Returns
+    -------
+    bool
+        True if all expected columns are present in the DataFrame, False otherwise.
+        
+    Raises
+    ------
+    ValueError
+        If any of the expected columns are not present in the DataFrame.
+        
+    Examples
+    --------
+    >>> df = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
+    >>> check_expected_columns(df, ['A', 'B'])
+    True
+    
+    >>> check_expected_columns(df, ['A', 'C'])
+    ValueError: The following columns are missing: ['C']
+    """
+    
+    missing_columns = [col for col in expected_columns if col not in df.columns]
+    
+    if missing_columns:
+        raise ValueError(f"The following columns are missing: {missing_columns}")
+    
+    return True
+
+
+def is_valid_primary_key(df: pd.DataFrame, column_name: str) -> bool:
+    """
+    Checks if a specified column in a DataFrame can serve as a valid primary key.
+    
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The input DataFrame to be checked.
+    column_name : str
+        The name of the column to check.
+        
+    Returns
+    -------
+    bool
+        True if the column can serve as a valid primary key, False otherwise.
+        
+    Raises
+    ------
+    ValueError
+        If the specified column does not exist in the DataFrame.
+        
+    Examples
+    --------
+    >>> df = pd.DataFrame({'A': [1, 2, 3], 'B': [4, 5, 6]})
+    >>> is_valid_primary_key(df, 'A')
+    True
+    
+    >>> df = pd.DataFrame({'A': [1, 2, 2], 'B': [4, 5, 6]})
+    >>> is_valid_primary_key(df, 'A')
+    False
+    """
+    
+    if column_name not in df.columns:
+        raise ValueError(f"Column '{column_name}' does not exist in the DataFrame.")
+    
+    # Check for NaN values
+    if df[column_name].isnull().any():
+        return False
+    
+    # Check for unique values
+    if not df[column_name].is_unique:
+        return False
+    
+    return True
+
+def get_non_empty_files(start_path: str, extensions: tuple = ('.fasta', '.fna')) -> str:
+    """
+    Generator that yields non-empty files from a specified directory and its subdirectories based on the given extensions.
+
+    :param start_path: The path to the directory from which to start the search.
+    :type start_path: str
+
+    :param extensions: A tuple of file extensions to look for (default is ('.fasta', '.fna')).
+                       The function also automatically checks for compressed versions with '.gz'.
+    :type extensions: tuple
+
+    :return: Yields filenames that match the specified extensions and are non-empty.
+    :rtype: str
+    """
+    
+    for dirpath, _, filenames in os.walk(start_path):
+        for filename in filenames:
+            filepath = os.path.join(dirpath, filename)
+            if any(filename.endswith(ext) or filename.endswith(ext + '.gz') for ext in extensions) and os.path.getsize(filepath) > 0:
+                yield filename
+
+
+
+def truncate_zero_columns(arr: np.ndarray) -> np.ndarray:
+    """
+    Truncate all trailing columns composed entirely of zeros in a given 2D numpy array.
+    
+    :param arr: Input 2D numpy array.
+    :type arr: np.ndarray
+
+    :return: A new array with trailing zero columns removed.
+    :rtype: np.ndarray
+    """
+    
+    # Iterate over columns from the end
+    for idx in range(arr.shape[1]-1, -1, -1):
+        if np.any(arr[:, idx]):
+            return arr[:, :(idx+1)]
+    return np.empty((arr.shape[0], 0))
+
+
+import os
+
+def create_directory_for_filepath(filepath: str) -> None:
+    """
+    Given a file path, creates the underlying directory structure if it doesn't already exist.
+
+    Args:
+        filepath (str): The path to the file for which the directory structure should be created.
+
+    Raises:
+        ValueError: If the provided path is empty or None.
+        OSError: If there's an error creating the directory structure.
+    """
+    
+    if not filepath:
+        raise ValueError("The provided filepath is empty or None.")
+    
+    directory = os.path.dirname(filepath)
+    
+    if directory and not os.path.exists(directory):
+        try:
+            os.makedirs(directory)
+            print(f"Directory structure {directory} created successfully.")
+        except OSError as e:
+            raise OSError(f"Error creating directory structure {directory}. Error: {e}")
+
+# Example usage:
+# create_directory_for_filepath("/path/to/directory/that/might/not/exist/filename.txt")
+
+def check_file_exists(file_path: str) -> bool:
+    """
+    Checks if the provided file path exists.
+
+    Args:
+        file_path (str): Path to the file.
+
+    Returns:
+        bool: True if the file exists, raises ValueError otherwise.
+    """
+    if os.path.exists(file_path):
+        return True
+    else:
+        raise ValueError(f"The provided file path '{file_path}' does not exist.")
+
+def count_gpus():
+    # Count NVIDIA GPUs
+    import torch
+    nvidia_gpu_count = torch.cuda.device_count()
+
+    # Count AMD GPUs
+    amd_gpu_count = 0
+    try:
+        clinfo_output = subprocess.check_output('clinfo').decode('utf-8')
+        amd_gpu_count = clinfo_output.count('Device Type: GPU')
+    except:
+        pass  # clinfo command might not be available
+
+    total_gpus = nvidia_gpu_count + amd_gpu_count
+
+    return total_gpus
+
+
+def create_hard_links(source_directory: str, target_directory: str, blacklist: list = []) -> None:
+    """
+    Creates hard links for all files from the source directory to the target directory.
+    
+    Args:
+        source_directory (str): The directory containing the original files.
+        target_directory (str): The directory where hard links will be created.
+        blacklist (list): List of filenames to exclude from creating hard links.
+    
+    Returns:
+        None
+    """
+    
+    # Ensure the provided directories exist
+    if not os.path.exists(source_directory):
+        raise ValueError(f"The source directory '{source_directory}' does not exist.")
+    if not os.path.exists(target_directory):
+        os.makedirs(target_directory)
+    
+    # Iterate through the files in the source directory
+    for filename in os.listdir(source_directory):
+        source_file_path = os.path.join(source_directory, filename)
+        target_file_path = os.path.join(target_directory, filename)
+        
+        # Check for files to skip
+        if (filename.startswith('.') or 
+            filename.startswith('_') or 
+            os.path.isdir(source_file_path) or 
+            filename in blacklist):
+            continue
+        
+        # Create a hard link
+        os.link(source_file_path, target_file_path)
+
+    return f"Hard links created in {target_directory} from {source_directory}."
+
+# Example usage
+# create_hard_links("/path/to/source_directory", "/path/to/target_directory", blacklist=["file_to_skip.txt"])
+
+def create_selected_hard_links(source_directory: str, target_directory: str, filenames: list) -> None:
+    """
+    Creates hard links for the specified files from the source directory to the target directory.
+    
+    Args:
+        source_directory (str): The directory containing the original files.
+        target_directory (str): The directory where hard links will be created.
+        filenames (list): List of filenames for which hard links should be created.
+    
+    Returns:
+        None
+    """
+    
+    # Ensure the provided directories exist
+    if not os.path.exists(source_directory):
+        raise ValueError(f"The source directory '{source_directory}' does not exist.")
+    if not os.path.exists(target_directory):
+        os.makedirs(target_directory)
+    
+    # Iterate through the specified filenames
+    for filename in filenames:
+        source_file_path = os.path.join(source_directory, filename)
+        target_file_path = os.path.join(target_directory, filename)
+        
+        # Ensure the file exists in the source directory
+        if not os.path.isfile(source_file_path):
+            print(f"Warning: {filename} does not exist in the source directory. Skipping.")
+            continue
+        
+        # Create a hard link
+        try:
+            os.link(source_file_path, target_file_path)
+        except FileExistsError:
+            print(f'The target hard link {target_file_path} exist. Skipping...')
+
+    return f"Hard links for specified files created in {target_directory} from {source_directory}."
+
+def remove_hidden_files(directory: str) -> None:
+    """
+    Removes all files recursively in a folder that start with '.' or '_'.
+    
+    Args:
+        directory (str): The directory from which hidden files should be removed.
+    
+    Returns:
+        None
+    """
+    
+    # Ensure the directory exists
+    if not os.path.exists(directory):
+        raise ValueError(f"The directory '{directory}' does not exist.")
+    
+    # Use os.walk to iterate through all subdirectories and files
+    for dirpath, dirnames, filenames in os.walk(directory, topdown=False):
+        
+        # Filter out directories starting with '.' or '_'
+        dirnames[:] = [d for d in dirnames if not d.startswith('.') and not d.startswith('_')]
+        
+        # Remove files starting with '.' or '_'
+        for filename in filenames:
+            if filename.startswith('.') or filename.startswith('_'):
+                file_path = os.path.join(dirpath, filename)
+                os.remove(file_path)
+                print(f"Removed: {file_path}")
+                
+    print(f"All hidden files removed from {directory}.")

prokbert_tokenizer.py

@@ -0,0 +1,429 @@
+# coding=utf-8
+# Based on https://github.com/huggingface/transformers/blob/main/src/transformers/models/bert/tokenization_bert.py
+
+
+# ProkBERT tokenizer stuff
+
+import collections
+import os
+import unicodedata
+from typing import List, Optional, Tuple, Union
+from copy import deepcopy
+from transformers import PreTrainedTokenizer
+from transformers.tokenization_utils import _is_control, _is_punctuation, _is_whitespace
+from transformers.utils import logging
+
+# These utils contains the tools needed by the ProkBERT tokenizer
+
+from config_utils import *
+from sequtils import *
+
+import logging as logger
+
+#logger = logging.get_logger(__name__)
+
+VOCAB_FILES_NAMES = {"vocab_file": "vocab.txt"}
+
+# models prokbert-mini-k6s1, prokbert-large-k6s2, prokbert-large-k6s1
+
+
+PRETRAINED_VOCAB_FILES_MAP = {
+    "vocab_file": {
+        "prokbert-mini-k6s1": "prokbert-base-dna6/vocab.txt",
+        "prokbert-large-k6s1": "prokbert-base-dna6/vocab.txt",
+        "prokbert-large-k6s2": "prokbert-base-dna6/vocab.txt"
+    }
+}
+
+
+PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {
+    "prokbert-mini-k6s1": 1024,
+    "prokbert-large-k6s1": 1024,
+    "prokbert-large-k6s2": 1024
+}
+
+PRETRAINED_INIT_CONFIGURATION = {
+    "prokbert-mini-k6s1": {"do_upper_case": True},
+    "prokbert-large-k6s1": {"do_upper_case": True},
+    "prokbert-large-k6s2": {"do_upper_case": True}
+
+}
+
+
+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):
+        token = token.rstrip("\n")
+        vocab[token] = index
+    return vocab
+
+
+class ProkBERTTokenizer(PreTrainedTokenizer):
+    """Custom tokenizer for ProkBERT."""
+    
+    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]"
+
+
+    def __init__(self, 
+                 tokenization_params: Dict = {},
+                 segmentation_params: Dict = {},
+                 comp_params: Dict = {},
+                 operation_space: str = 'sequence',
+                 **kwargs):
+        """Initialize the ProkBERT tokenizer.
+        
+        Args:
+            tokenization_params (Dict, optional): Tokenization parameters. Defaults to {}.
+            segmentation_params (Dict, optional): Segmentation parameters. Defaults to {}.
+            comp_params (Dict, optional): Computational parameters. Defaults to {}.
+            operation_space (str, optional): Specifies the operation mode. Can be 'kmer' or 'sequence'. Defaults to 'kmer'.
+        """
+        super().__init__(cls_token=ProkBERTTokenizer.default_cls_token,
+                         **kwargs)
+        
+        self.defconfig = SeqConfig()
+        self.tokenization_params = self.defconfig.get_and_set_tokenization_parameters(tokenization_params)
+        self.segmentation_params = self.defconfig.get_and_set_segmentation_parameters(segmentation_params)
+        self.comp_params = self.defconfig.get_and_set_computational_parameters(comp_params)
+        self.operation_space = operation_space
+
+        vocab_file = self.tokenization_params['vocabfile']
+        self.vocab = self.tokenization_params['vocabmap']
+        self.id2token = {v: k for k, v in self.vocab.items()}
+        self.max_len = self.tokenization_params['max_segment_length']
+
+        if self.operation_space == 'sequence':
+            token_extension = sorted(list(set(generate_kmers(ProkBERTTokenizer.extended_nucleotide_abc, self.tokenization_params['kmer'])) - \
+                 set(generate_kmers(ProkBERTTokenizer.nucleotide_abc, self.tokenization_params['kmer'])) ))
+            self.extended_vocab = deepcopy(self.vocab)
+            for token in token_extension:
+                self.extended_vocab[token] = 4
+                            
+            self.unk_token = ProkBERTTokenizer.sequence_unk_token * self.tokenization_params['shift']
+            self.mask_token = '*'
+            self.extended_vocab[self.mask_token] = self.vocab['[MASK]']
+
+            full_unk = 'N' * self.tokenization_params['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.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 __len__(self) -> int:
+        return len(self.vocab)
+
+
+    def tokenize(self, text: str, lca_shift: int = 0, all: bool = False) -> Union[List[str], Tuple[List[List[str]], List[List[str]]]]:
+        """
+        Tokenizes a given segment.
+
+        Args:
+            text (str): The DNA segment to tokenize.
+            lca_shift (int, optional): Which tokenized vector belonging to the specified LCA offset should be returned. Defaults to 0.
+            all (bool, optional): If True, returns all possible tokenizations. Defaults to False.
+        
+        Returns:
+            Union[List[str], Tuple[List[List[str]], List[List[str]]]]: Tokenized segment or tuple of all possible tokenizations.
+        
+        Usage Example:
+            >>> tokenizer = ProkBERTTokenizer(...)
+            >>> segment = 'AATCAAGGAATTATTATCGTT'
+            >>> tokens, kmers = tokenizer.tokenize(segment, all=True)
+            >>> print(tokens)
+            ...
+        """
+        tokenized_segments, kmerized_segments = lca_tokenize_segment(text, self.tokenization_params)
+        if all:
+            return tokenized_segments, kmerized_segments
+        else:
+            return kmerized_segments[lca_shift]
+
+    def _convert_token_to_id(self, token):
+        """Converts a token (str) in an id using the vocab."""
+        return self.vocab.get(token, self.vocab.get(self.unk_token))
+
+    def _convert_id_to_token(self, index):
+        """Converts an index (integer) in a token (str) using the vocab."""
+        return self.ids_to_tokens.get(index, self.unk_token)
+            
+
+    def depr_convert_ids_to_tokens(self, ids: Union[int, List[int]]) -> List[str]:
+        """
+        Converts tokens to their corresponding IDs.
+
+        Args:
+            tokens (List[str]): List of tokens to convert.
+        
+        Returns:
+            List[int]: List of corresponding token IDs.
+        
+        Usage Example:
+            >>> tokenizer = ProkBERTTokenizer(...)
+            >>> tokens = ['AATCAA', 'TCAAGG']
+            >>> ids = tokenizer.convert_tokens_to_ids(tokens)
+            >>> print(ids)
+            ...
+        """
+
+        if isinstance(ids, int):
+            token_ids = self.vocab.get(ids, self.vocab[self.unk_token])
+
+
+        if self.operation_space == 'sequence':
+            token_ids = [self.vocab.get(token, self.vocab[self.full_unk_token]) for token in tokens]
+        
+        else:
+            token_ids = [self.vocab.get(token, self.vocab[self.unk_token]) for token in tokens]
+        
+        return token_ids
+
+    def convert_ids_to_tokens(self, ids: Union[int, List[int]]) -> Union[str, List[str]]:
+        """
+        Converts token IDs back to their original tokens.
+        
+        Args:
+            ids (List[int]): List of token IDs to convert.
+        
+        Returns:
+            List[str]: List of corresponding tokens.
+        
+        Usage Example:
+            >>> tokenizer = ProkBERTTokenizer(...)
+            >>> ids = [213, 3343]
+            >>> tokens = tokenizer.convert_ids_to_tokens(ids)
+            >>> print(tokens)
+            ...
+        """
+        if isinstance(ids, int):
+            ids = [ids]
+        if len(ids) == 1: 
+            #default_token_list = [self.id2token.get(ids[0], self.unk_token)]
+            return self.id2token.get(ids[0], self.unk_token)
+
+        if self.operation_space == 'kmer':
+            token_list = [self.id2token.get(id, self.unk_token) for id in ids]
+
+        elif self.operation_space == 'sequence':
+            token_list = []
+            # Handling the sentence start
+            if ids[0] == 2:
+                pass
+            else:
+                token_list.append(self.id2token.get(ids[0], self.unk_token))
+            if len(ids) > 1:
+                # if this is a kmer then we add accordingly. 
+                true_start_token = self.id2token.get(ids[1], self.unk_token)
+
+
+                token_list.append(true_start_token)
+            print(token_list)
+            if len(ids) >2:
+                # Adding the other tokens until the end
+                for token_id in ids[2:]:
+                    mapped_token_id = self.id2token.get(token_id, self.unk_token)
+                    if (mapped_token_id in self.special_tokens):
+                        act_token_value = ''
+                    else:
+                        act_token_value = mapped_token_id[-1*self.tokenization_params['shift']:]
+                        token_list.append(act_token_value)
+
+        return token_list
+    
+    
+    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:
+        """Saves the vocabulary to a 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,)
+
+    @classmethod
+    def from_pretrained(cls, vocab_file: str) -> 'ProkBERTTokenizer':
+        """Loads a pre-trained tokenizer.
+        
+        Args:
+            vocab_file (str): Path to the pre-trained tokenizer vocabulary file.
+        
+        Returns:
+            ProkBERTTokenizer: Loaded tokenizer instance.
+        """
+        return cls(vocab_file)
+
+    def encode_plus(self, text: str, lca_shift: int = 0, **kwargs) -> Dict[str, np.ndarray]:
+        """
+        Tokenizes a sequence and returns it in a format suitable for model input.
+        
+        Args:
+            text (str): The sequence to tokenize.
+            lca_shift (int, optional): LCA offset for tokenization. Defaults to 0.
+        
+        Returns:
+            Dict[str, np.ndarray]: Dictionary containing token IDs and attention masks.
+        
+        Usage Example:
+            >>> tokenizer = ProkBERTTokenizer(...)
+            >>> segment = 'AATCAAGGAATTATTATCGTT'
+            >>> encoded = tokenizer.encode_plus(segment)
+            >>> print(encoded)
+            ...
+        """
+        tokenized_segments, kmerized_segments = lca_tokenize_segment(text, self.tokenization_params)
+        input_ids = tokenized_segments[lca_shift]
+        attention_mask = [1] * len(input_ids)
+
+        # Padding
+        while len(input_ids) < self.max_len:
+            input_ids.append(0)
+            attention_mask.append(0)
+
+        return {
+            "input_ids": np.array(input_ids, dtype=self.comp_params['np_tokentype']),
+            "attention_mask": np.array(attention_mask, dtype=self.comp_params['np_tokentype'])
+        }
+    
+    def batch_encode_plus(self, sequences: List[str], lca_shift: int = 0, all: bool = False, **kwargs) -> Dict[str, List[List[int]]]:
+        """
+        Tokenizes multiple sequences and returns them in a format suitable for model input. It is assumed that sequences 
+        have already been preprocessed (i.e., segmented) and quality controlled. 
+
+        Args:
+        - sequences (List[str]): A list of DNA sequences to be tokenized.
+        - lca_shift (int, default=0): The LCA offset or windows to get the tokenized vector. If the required offset is >= shift, 
+        an error is raised.
+        - all (bool, default=False): Whether all possible tokenization vectors should be returned. If False, only the specified 
+        offset is used. 
+        - **kwargs: Additional arguments (like max_length, padding, etc.)
+
+        Returns:
+        - Dict[str, List[List[int]]]: A dictionary containing token IDs, attention masks, and token type IDs.
+        """
+        shift = self.tokenization_params['shift']
+        if lca_shift >= shift:
+            raise ValueError(f'The required offset {lca_shift} is invalid. The maximum offset should be < {shift}')
+        
+        # Parallel tokenization. First, create unique IDs for all sequences. 
+        sequence_ids = list(range(len(sequences)))
+        to_tokenize_data = (sequences, sequence_ids)
+        
+        # Tokenize each sequence
+        tokenization_results = batch_tokenize_segments_with_ids(
+            to_tokenize_data, 
+            self.tokenization_params, 
+            self.comp_params['cpu_cores_for_tokenization'],
+            self.comp_params['batch_size_tokenization'],
+            self.comp_params['np_tokentype']
+        )
+
+        # Generate input ids, token type ids, and attention masks
+        input_ids = []
+        token_type_ids = []
+        attention_masks = []
+        
+        if all:
+            for tokenized_vectors in tokenization_results.values():
+                for tokenized_vector in tokenized_vectors:
+                    input_ids.append(tokenized_vector)
+                    token_type_ids.append([0] * len(tokenized_vector))
+                    attention_masks.append([1] * len(tokenized_vector))
+        else:
+            for tokenized_vectors in tokenization_results.values():
+                selected_vector = tokenized_vectors[lca_shift]
+                input_ids.append(selected_vector)
+                token_type_ids.append([0] * len(selected_vector))
+                attention_masks.append([1] * len(selected_vector))
+
+        return {
+            "input_ids": input_ids,
+            "token_type_ids": token_type_ids,
+            "attention_mask": attention_masks
+        }
+    
+    def encode(self, segment: str,  lca_shift: int = 0, all: bool = False, add_special_tokens: bool = True, **kwargs) -> List[int]:
+        """
+        Encode a DNA sequence into its corresponding token IDs.
+        
+        Args:
+            text (str): The DNA segment to encode.
+            add_special_tokens (bool, optional): Whether to add special tokens like [CLS] and [SEP]. Defaults to True.
+        
+        Returns:
+            List[int]: Encoded token IDs.
+        
+        Usage Example:
+            >>> tokenizer = ProkBERTTokenizer(...)
+            >>> segment = 'AATCAAGGAATTATTATCGTT'
+            >>> ids = tokenizer.encode(segment)
+            >>> print(ids)
+            ...
+        """
+        shift = self.tokenization_params['shift']
+        if lca_shift >= shift:
+            raise ValueError(f'The required offset {lca_shift} is invalid. The maximum offset should be < {shift}')
+        
+        tokenized_segments, _ = lca_tokenize_segment(segment, self.tokenization_params)
+
+        # if all is set to True, then we return all the possible ids as a list
+        if all:
+            token_ids = tokenized_segments
+            if not add_special_tokens:
+                new_token_ids = []
+                for token_id_set in tokenized_segments:
+                    new_token_ids.append(token_id_set[1:len(token_id_set)-1])
+                token_ids = new_token_ids
+
+        else:
+            token_ids = tokenized_segments[lca_shift]
+            # Convert tokens to their corresponding IDs
+            # Add special tokens if needed
+            if not add_special_tokens:
+                token_ids = token_ids[1:len(token_ids)-1]
+
+        return token_ids
+    
+    def decode(self, ids):
+        tokens = self.convert_ids_to_tokens(ids)
+        return ''.join(tokens)
+    
+    def batch_decode(self, token_ids_list: List[List[int]], **kwargs) -> List[str]:
+        """
+        Decodes multiple token ID sequences back into their original sequences.
+        
+        Args:
+            token_ids_list (List[List[int]]): List of token ID sequences.
+        
+        Returns:
+            List[str]: List of decoded sequences.
+        
+        Usage Example:
+            >>> tokenizer = ProkBERTTokenizer(...)
+            >>> ids = [[2, 213, 3343, 165, 2580, 248, 3905, 978, 3296, 3]]
+            >>> sequences = tokenizer.batch_decode(ids)
+            >>> print(sequences)
+            ...
+        """
+        return [self.decode(token_ids) for token_ids in token_ids_list]

special_tokens_map.json

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

tokenizer_config.json

@@ -0,0 +1,6 @@
+{
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "model_max_length": 1000000000000000019884624838656,
+  "tokenizer_class": "ProkBERTTokenizer"
+}

vocab.txt

@@ -0,0 +1 @@
+[PAD]\n[UNK]\n[CLS]\n[SEP]\n[MASK]\nAAAAAA\nAAAAAC\nAAAAAG\nAAAAAT\nAAAACA\nAAAACC\nAAAACG\nAAAACT\nAAAAGA\nAAAAGC\nAAAAGG\nAAAAGT\nAAAATA\nAAAATC\nAAAATG\nAAAATT\nAAACAA\nAAACAC\nAAACAG\nAAACAT\nAAACCA\nAAACCC\nAAACCG\nAAACCT\nAAACGA\nAAACGC\nAAACGG\nAAACGT\nAAACTA\nAAACTC\nAAACTG\nAAACTT\nAAAGAA\nAAAGAC\nAAAGAG\nAAAGAT\nAAAGCA\nAAAGCC\nAAAGCG\nAAAGCT\nAAAGGA\nAAAGGC\nAAAGGG\nAAAGGT\nAAAGTA\nAAAGTC\nAAAGTG\nAAAGTT\nAAATAA\nAAATAC\nAAATAG\nAAATAT\nAAATCA\nAAATCC\nAAATCG\nAAATCT\nAAATGA\nAAATGC\nAAATGG\nAAATGT\nAAATTA\nAAATTC\nAAATTG\nAAATTT\nAACAAA\nAACAAC\nAACAAG\nAACAAT\nAACACA\nAACACC\nAACACG\nAACACT\nAACAGA\nAACAGC\nAACAGG\nAACAGT\nAACATA\nAACATC\nAACATG\nAACATT\nAACCAA\nAACCAC\nAACCAG\nAACCAT\nAACCCA\nAACCCC\nAACCCG\nAACCCT\nAACCGA\nAACCGC\nAACCGG\nAACCGT\nAACCTA\nAACCTC\nAACCTG\nAACCTT\nAACGAA\nAACGAC\nAACGAG\nAACGAT\nAACGCA\nAACGCC\nAACGCG\nAACGCT\nAACGGA\nAACGGC\nAACGGG\nAACGGT\nAACGTA\nAACGTC\nAACGTG\nAACGTT\nAACTAA\nAACTAC\nAACTAG\nAACTAT\nAACTCA\nAACTCC\nAACTCG\nAACTCT\nAACTGA\nAACTGC\nAACTGG\nAACTGT\nAACTTA\nAACTTC\nAACTTG\nAACTTT\nAAGAAA\nAAGAAC\nAAGAAG\nAAGAAT\nAAGACA\nAAGACC\nAAGACG\nAAGACT\nAAGAGA\nAAGAGC\nAAGAGG\nAAGAGT\nAAGATA\nAAGATC\nAAGATG\nAAGATT\nAAGCAA\nAAGCAC\nAAGCAG\nAAGCAT\nAAGCCA\nAAGCCC\nAAGCCG\nAAGCCT\nAAGCGA\nAAGCGC\nAAGCGG\nAAGCGT\nAAGCTA\nAAGCTC\nAAGCTG\nAAGCTT\nAAGGAA\nAAGGAC\nAAGGAG\nAAGGAT\nAAGGCA\nAAGGCC\nAAGGCG\nAAGGCT\nAAGGGA\nAAGGGC\nAAGGGG\nAAGGGT\nAAGGTA\nAAGGTC\nAAGGTG\nAAGGTT\nAAGTAA\nAAGTAC\nAAGTAG\nAAGTAT\nAAGTCA\nAAGTCC\nAAGTCG\nAAGTCT\nAAGTGA\nAAGTGC\nAAGTGG\nAAGTGT\nAAGTTA\nAAGTTC\nAAGTTG\nAAGTTT\nAATAAA\nAATAAC\nAATAAG\nAATAAT\nAATACA\nAATACC\nAATACG\nAATACT\nAATAGA\nAATAGC\nAATAGG\nAATAGT\nAATATA\nAATATC\nAATATG\nAATATT\nAATCAA\nAATCAC\nAATCAG\nAATCAT\nAATCCA\nAATCCC\nAATCCG\nAATCCT\nAATCGA\nAATCGC\nAATCGG\nAATCGT\nAATCTA\nAATCTC\nAATCTG\nAATCTT\nAATGAA\nAATGAC\nAATGAG\nAATGAT\nAATGCA\nAATGCC\nAATGCG\nAATGCT\nAATGGA\nAATGGC\nAATGGG\nAATGGT\nAATGTA\nAATGTC\nAATGTG\nAATGTT\nAATTAA\nAATTAC\nAATTAG\nAATTAT\nAATTCA\nAATTCC\nAATTCG\nAATTCT\nAATTGA\nAATTGC\nAATTGG\nAATTGT\nAATTTA\nAATTTC\nAATTTG\nAATTTT\nACAAAA\nACAAAC\nACAAAG\nACAAAT\nACAACA\nACAACC\nACAACG\nACAACT\nACAAGA\nACAAGC\nACAAGG\nACAAGT\nACAATA\nACAATC\nACAATG\nACAATT\nACACAA\nACACAC\nACACAG\nACACAT\nACACCA\nACACCC\nACACCG\nACACCT\nACACGA\nACACGC\nACACGG\nACACGT\nACACTA\nACACTC\nACACTG\nACACTT\nACAGAA\nACAGAC\nACAGAG\nACAGAT\nACAGCA\nACAGCC\nACAGCG\nACAGCT\nACAGGA\nACAGGC\nACAGGG\nACAGGT\nACAGTA\nACAGTC\nACAGTG\nACAGTT\nACATAA\nACATAC\nACATAG\nACATAT\nACATCA\nACATCC\nACATCG\nACATCT\nACATGA\nACATGC\nACATGG\nACATGT\nACATTA\nACATTC\nACATTG\nACATTT\nACCAAA\nACCAAC\nACCAAG\nACCAAT\nACCACA\nACCACC\nACCACG\nACCACT\nACCAGA\nACCAGC\nACCAGG\nACCAGT\nACCATA\nACCATC\nACCATG\nACCATT\nACCCAA\nACCCAC\nACCCAG\nACCCAT\nACCCCA\nACCCCC\nACCCCG\nACCCCT\nACCCGA\nACCCGC\nACCCGG\nACCCGT\nACCCTA\nACCCTC\nACCCTG\nACCCTT\nACCGAA\nACCGAC\nACCGAG\nACCGAT\nACCGCA\nACCGCC\nACCGCG\nACCGCT\nACCGGA\nACCGGC\nACCGGG\nACCGGT\nACCGTA\nACCGTC\nACCGTG\nACCGTT\nACCTAA\nACCTAC\nACCTAG\nACCTAT\nACCTCA\nACCTCC\nACCTCG\nACCTCT\nACCTGA\nACCTGC\nACCTGG\nACCTGT\nACCTTA\nACCTTC\nACCTTG\nACCTTT\nACGAAA\nACGAAC\nACGAAG\nACGAAT\nACGACA\nACGACC\nACGACG\nACGACT\nACGAGA\nACGAGC\nACGAGG\nACGAGT\nACGATA\nACGATC\nACGATG\nACGATT\nACGCAA\nACGCAC\nACGCAG\nACGCAT\nACGCCA\nACGCCC\nACGCCG\nACGCCT\nACGCGA\nACGCGC\nACGCGG\nACGCGT\nACGCTA\nACGCTC\nACGCTG\nACGCTT\nACGGAA\nACGGAC\nACGGAG\nACGGAT\nACGGCA\nACGGCC\nACGGCG\nACGGCT\nACGGGA\nACGGGC\nACGGGG\nACGGGT\nACGGTA\nACGGTC\nACGGTG\nACGGTT\nACGTAA\nACGTAC\nACGTAG\nACGTAT\nACGTCA\nACGTCC\nACGTCG\nACGTCT\nACGTGA\nACGTGC\nACGTGG\nACGTGT\nACGTTA\nACGTTC\nACGTTG\nACGTTT\nACTAAA\nACTAAC\nACTAAG\nACTAAT\nACTACA\nACTACC\nACTACG\nACTACT\nACTAGA\nACTAGC\nACTAGG\nACTAGT\nACTATA\nACTATC\nACTATG\nACTATT\nACTCAA\nACTCAC\nACTCAG\nACTCAT\nACTCCA\nACTCCC\nACTCCG\nACTCCT\nACTCGA\nACTCGC\nACTCGG\nACTCGT\nACTCTA\nACTCTC\nACTCTG\nACTCTT\nACTGAA\nACTGAC\nACTGAG\nACTGAT\nACTGCA\nACTGCC\nACTGCG\nACTGCT\nACTGGA\nACTGGC\nACTGGG\nACTGGT\nACTGTA\nACTGTC\nACTGTG\nACTGTT\nACTTAA\nACTTAC\nACTTAG\nACTTAT\nACTTCA\nACTTCC\nACTTCG\nACTTCT\nACTTGA\nACTTGC\nACTTGG\nACTTGT\nACTTTA\nACTTTC\nACTTTG\nACTTTT\nAGAAAA\nAGAAAC\nAGAAAG\nAGAAAT\nAGAACA\nAGAACC\nAGAACG\nAGAACT\nAGAAGA\nAGAAGC\nAGAAGG\nAGAAGT\nAGAATA\nAGAATC\nAGAATG\nAGAATT\nAGACAA\nAGACAC\nAGACAG\nAGACAT\nAGACCA\nAGACCC\nAGACCG\nAGACCT\nAGACGA\nAGACGC\nAGACGG\nAGACGT\nAGACTA\nAGACTC\nAGACTG\nAGACTT\nAGAGAA\nAGAGAC\nAGAGAG\nAGAGAT\nAGAGCA\nAGAGCC\nAGAGCG\nAGAGCT\nAGAGGA\nAGAGGC\nAGAGGG\nAGAGGT\nAGAGTA\nAGAGTC\nAGAGTG\nAGAGTT\nAGATAA\nAGATAC\nAGATAG\nAGATAT\nAGATCA\nAGATCC\nAGATCG\nAGATCT\nAGATGA\nAGATGC\nAGATGG\nAGATGT\nAGATTA\nAGATTC\nAGATTG\nAGATTT\nAGCAAA\nAGCAAC\nAGCAAG\nAGCAAT\nAGCACA\nAGCACC\nAGCACG\nAGCACT\nAGCAGA\nAGCAGC\nAGCAGG\nAGCAGT\nAGCATA\nAGCATC\nAGCATG\nAGCATT\nAGCCAA\nAGCCAC\nAGCCAG\nAGCCAT\nAGCCCA\nAGCCCC\nAGCCCG\nAGCCCT\nAGCCGA\nAGCCGC\nAGCCGG\nAGCCGT\nAGCCTA\nAGCCTC\nAGCCTG\nAGCCTT\nAGCGAA\nAGCGAC\nAGCGAG\nAGCGAT\nAGCGCA\nAGCGCC\nAGCGCG\nAGCGCT\nAGCGGA\nAGCGGC\nAGCGGG\nAGCGGT\nAGCGTA\nAGCGTC\nAGCGTG\nAGCGTT\nAGCTAA\nAGCTAC\nAGCTAG\nAGCTAT\nAGCTCA\nAGCTCC\nAGCTCG\nAGCTCT\nAGCTGA\nAGCTGC\nAGCTGG\nAGCTGT\nAGCTTA\nAGCTTC\nAGCTTG\nAGCTTT\nAGGAAA\nAGGAAC\nAGGAAG\nAGGAAT\nAGGACA\nAGGACC\nAGGACG\nAGGACT\nAGGAGA\nAGGAGC\nAGGAGG\nAGGAGT\nAGGATA\nAGGATC\nAGGATG\nAGGATT\nAGGCAA\nAGGCAC\nAGGCAG\nAGGCAT\nAGGCCA\nAGGCCC\nAGGCCG\nAGGCCT\nAGGCGA\nAGGCGC\nAGGCGG\nAGGCGT\nAGGCTA\nAGGCTC\nAGGCTG\nAGGCTT\nAGGGAA\nAGGGAC\nAGGGAG\nAGGGAT\nAGGGCA\nAGGGCC\nAGGGCG\nAGGGCT\nAGGGGA\nAGGGGC\nAGGGGG\nAGGGGT\nAGGGTA\nAGGGTC\nAGGGTG\nAGGGTT\nAGGTAA\nAGGTAC\nAGGTAG\nAGGTAT\nAGGTCA\nAGGTCC\nAGGTCG\nAGGTCT\nAGGTGA\nAGGTGC\nAGGTGG\nAGGTGT\nAGGTTA\nAGGTTC\nAGGTTG\nAGGTTT\nAGTAAA\nAGTAAC\nAGTAAG\nAGTAAT\nAGTACA\nAGTACC\nAGTACG\nAGTACT\nAGTAGA\nAGTAGC\nAGTAGG\nAGTAGT\nAGTATA\nAGTATC\nAGTATG\nAGTATT\nAGTCAA\nAGTCAC\nAGTCAG\nAGTCAT\nAGTCCA\nAGTCCC\nAGTCCG\nAGTCCT\nAGTCGA\nAGTCGC\nAGTCGG\nAGTCGT\nAGTCTA\nAGTCTC\nAGTCTG\nAGTCTT\nAGTGAA\nAGTGAC\nAGTGAG\nAGTGAT\nAGTGCA\nAGTGCC\nAGTGCG\nAGTGCT\nAGTGGA\nAGTGGC\nAGTGGG\nAGTGGT\nAGTGTA\nAGTGTC\nAGTGTG\nAGTGTT\nAGTTAA\nAGTTAC\nAGTTAG\nAGTTAT\nAGTTCA\nAGTTCC\nAGTTCG\nAGTTCT\nAGTTGA\nAGTTGC\nAGTTGG\nAGTTGT\nAGTTTA\nAGTTTC\nAGTTTG\nAGTTTT\nATAAAA\nATAAAC\nATAAAG\nATAAAT\nATAACA\nATAACC\nATAACG\nATAACT\nATAAGA\nATAAGC\nATAAGG\nATAAGT\nATAATA\nATAATC\nATAATG\nATAATT\nATACAA\nATACAC\nATACAG\nATACAT\nATACCA\nATACCC\nATACCG\nATACCT\nATACGA\nATACGC\nATACGG\nATACGT\nATACTA\nATACTC\nATACTG\nATACTT\nATAGAA\nATAGAC\nATAGAG\nATAGAT\nATAGCA\nATAGCC\nATAGCG\nATAGCT\nATAGGA\nATAGGC\nATAGGG\nATAGGT\nATAGTA\nATAGTC\nATAGTG\nATAGTT\nATATAA\nATATAC\nATATAG\nATATAT\nATATCA\nATATCC\nATATCG\nATATCT\nATATGA\nATATGC\nATATGG\nATATGT\nATATTA\nATATTC\nATATTG\nATATTT\nATCAAA\nATCAAC\nATCAAG\nATCAAT\nATCACA\nATCACC\nATCACG\nATCACT\nATCAGA\nATCAGC\nATCAGG\nATCAGT\nATCATA\nATCATC\nATCATG\nATCATT\nATCCAA\nATCCAC\nATCCAG\nATCCAT\nATCCCA\nATCCCC\nATCCCG\nATCCCT\nATCCGA\nATCCGC\nATCCGG\nATCCGT\nATCCTA\nATCCTC\nATCCTG\nATCCTT\nATCGAA\nATCGAC\nATCGAG\nATCGAT\nATCGCA\nATCGCC\nATCGCG\nATCGCT\nATCGGA\nATCGGC\nATCGGG\nATCGGT\nATCGTA\nATCGTC\nATCGTG\nATCGTT\nATCTAA\nATCTAC\nATCTAG\nATCTAT\nATCTCA\nATCTCC\nATCTCG\nATCTCT\nATCTGA\nATCTGC\nATCTGG\nATCTGT\nATCTTA\nATCTTC\nATCTTG\nATCTTT\nATGAAA\nATGAAC\nATGAAG\nATGAAT\nATGACA\nATGACC\nATGACG\nATGACT\nATGAGA\nATGAGC\nATGAGG\nATGAGT\nATGATA\nATGATC\nATGATG\nATGATT\nATGCAA\nATGCAC\nATGCAG\nATGCAT\nATGCCA\nATGCCC\nATGCCG\nATGCCT\nATGCGA\nATGCGC\nATGCGG\nATGCGT\nATGCTA\nATGCTC\nATGCTG\nATGCTT\nATGGAA\nATGGAC\nATGGAG\nATGGAT\nATGGCA\nATGGCC\nATGGCG\nATGGCT\nATGGGA\nATGGGC\nATGGGG\nATGGGT\nATGGTA\nATGGTC\nATGGTG\nATGGTT\nATGTAA\nATGTAC\nATGTAG\nATGTAT\nATGTCA\nATGTCC\nATGTCG\nATGTCT\nATGTGA\nATGTGC\nATGTGG\nATGTGT\nATGTTA\nATGTTC\nATGTTG\nATGTTT\nATTAAA\nATTAAC\nATTAAG\nATTAAT\nATTACA\nATTACC\nATTACG\nATTACT\nATTAGA\nATTAGC\nATTAGG\nATTAGT\nATTATA\nATTATC\nATTATG\nATTATT\nATTCAA\nATTCAC\nATTCAG\nATTCAT\nATTCCA\nATTCCC\nATTCCG\nATTCCT\nATTCGA\nATTCGC\nATTCGG\nATTCGT\nATTCTA\nATTCTC\nATTCTG\nATTCTT\nATTGAA\nATTGAC\nATTGAG\nATTGAT\nATTGCA\nATTGCC\nATTGCG\nATTGCT\nATTGGA\nATTGGC\nATTGGG\nATTGGT\nATTGTA\nATTGTC\nATTGTG\nATTGTT\nATTTAA\nATTTAC\nATTTAG\nATTTAT\nATTTCA\nATTTCC\nATTTCG\nATTTCT\nATTTGA\nATTTGC\nATTTGG\nATTTGT\nATTTTA\nATTTTC\nATTTTG\nATTTTT\nCAAAAA\nCAAAAC\nCAAAAG\nCAAAAT\nCAAACA\nCAAACC\nCAAACG\nCAAACT\nCAAAGA\nCAAAGC\nCAAAGG\nCAAAGT\nCAAATA\nCAAATC\nCAAATG\nCAAATT\nCAACAA\nCAACAC\nCAACAG\nCAACAT\nCAACCA\nCAACCC\nCAACCG\nCAACCT\nCAACGA\nCAACGC\nCAACGG\nCAACGT\nCAACTA\nCAACTC\nCAACTG\nCAACTT\nCAAGAA\nCAAGAC\nCAAGAG\nCAAGAT\nCAAGCA\nCAAGCC\nCAAGCG\nCAAGCT\nCAAGGA\nCAAGGC\nCAAGGG\nCAAGGT\nCAAGTA\nCAAGTC\nCAAGTG\nCAAGTT\nCAATAA\nCAATAC\nCAATAG\nCAATAT\nCAATCA\nCAATCC\nCAATCG\nCAATCT\nCAATGA\nCAATGC\nCAATGG\nCAATGT\nCAATTA\nCAATTC\nCAATTG\nCAATTT\nCACAAA\nCACAAC\nCACAAG\nCACAAT\nCACACA\nCACACC\nCACACG\nCACACT\nCACAGA\nCACAGC\nCACAGG\nCACAGT\nCACATA\nCACATC\nCACATG\nCACATT\nCACCAA\nCACCAC\nCACCAG\nCACCAT\nCACCCA\nCACCCC\nCACCCG\nCACCCT\nCACCGA\nCACCGC\nCACCGG\nCACCGT\nCACCTA\nCACCTC\nCACCTG\nCACCTT\nCACGAA\nCACGAC\nCACGAG\nCACGAT\nCACGCA\nCACGCC\nCACGCG\nCACGCT\nCACGGA\nCACGGC\nCACGGG\nCACGGT\nCACGTA\nCACGTC\nCACGTG\nCACGTT\nCACTAA\nCACTAC\nCACTAG\nCACTAT\nCACTCA\nCACTCC\nCACTCG\nCACTCT\nCACTGA\nCACTGC\nCACTGG\nCACTGT\nCACTTA\nCACTTC\nCACTTG\nCACTTT\nCAGAAA\nCAGAAC\nCAGAAG\nCAGAAT\nCAGACA\nCAGACC\nCAGACG\nCAGACT\nCAGAGA\nCAGAGC\nCAGAGG\nCAGAGT\nCAGATA\nCAGATC\nCAGATG\nCAGATT\nCAGCAA\nCAGCAC\nCAGCAG\nCAGCAT\nCAGCCA\nCAGCCC\nCAGCCG\nCAGCCT\nCAGCGA\nCAGCGC\nCAGCGG\nCAGCGT\nCAGCTA\nCAGCTC\nCAGCTG\nCAGCTT\nCAGGAA\nCAGGAC\nCAGGAG\nCAGGAT\nCAGGCA\nCAGGCC\nCAGGCG\nCAGGCT\nCAGGGA\nCAGGGC\nCAGGGG\nCAGGGT\nCAGGTA\nCAGGTC\nCAGGTG\nCAGGTT\nCAGTAA\nCAGTAC\nCAGTAG\nCAGTAT\nCAGTCA\nCAGTCC\nCAGTCG\nCAGTCT\nCAGTGA\nCAGTGC\nCAGTGG\nCAGTGT\nCAGTTA\nCAGTTC\nCAGTTG\nCAGTTT\nCATAAA\nCATAAC\nCATAAG\nCATAAT\nCATACA\nCATACC\nCATACG\nCATACT\nCATAGA\nCATAGC\nCATAGG\nCATAGT\nCATATA\nCATATC\nCATATG\nCATATT\nCATCAA\nCATCAC\nCATCAG\nCATCAT\nCATCCA\nCATCCC\nCATCCG\nCATCCT\nCATCGA\nCATCGC\nCATCGG\nCATCGT\nCATCTA\nCATCTC\nCATCTG\nCATCTT\nCATGAA\nCATGAC\nCATGAG\nCATGAT\nCATGCA\nCATGCC\nCATGCG\nCATGCT\nCATGGA\nCATGGC\nCATGGG\nCATGGT\nCATGTA\nCATGTC\nCATGTG\nCATGTT\nCATTAA\nCATTAC\nCATTAG\nCATTAT\nCATTCA\nCATTCC\nCATTCG\nCATTCT\nCATTGA\nCATTGC\nCATTGG\nCATTGT\nCATTTA\nCATTTC\nCATTTG\nCATTTT\nCCAAAA\nCCAAAC\nCCAAAG\nCCAAAT\nCCAACA\nCCAACC\nCCAACG\nCCAACT\nCCAAGA\nCCAAGC\nCCAAGG\nCCAAGT\nCCAATA\nCCAATC\nCCAATG\nCCAATT\nCCACAA\nCCACAC\nCCACAG\nCCACAT\nCCACCA\nCCACCC\nCCACCG\nCCACCT\nCCACGA\nCCACGC\nCCACGG\nCCACGT\nCCACTA\nCCACTC\nCCACTG\nCCACTT\nCCAGAA\nCCAGAC\nCCAGAG\nCCAGAT\nCCAGCA\nCCAGCC\nCCAGCG\nCCAGCT\nCCAGGA\nCCAGGC\nCCAGGG\nCCAGGT\nCCAGTA\nCCAGTC\nCCAGTG\nCCAGTT\nCCATAA\nCCATAC\nCCATAG\nCCATAT\nCCATCA\nCCATCC\nCCATCG\nCCATCT\nCCATGA\nCCATGC\nCCATGG\nCCATGT\nCCATTA\nCCATTC\nCCATTG\nCCATTT\nCCCAAA\nCCCAAC\nCCCAAG\nCCCAAT\nCCCACA\nCCCACC\nCCCACG\nCCCACT\nCCCAGA\nCCCAGC\nCCCAGG\nCCCAGT\nCCCATA\nCCCATC\nCCCATG\nCCCATT\nCCCCAA\nCCCCAC\nCCCCAG\nCCCCAT\nCCCCCA\nCCCCCC\nCCCCCG\nCCCCCT\nCCCCGA\nCCCCGC\nCCCCGG\nCCCCGT\nCCCCTA\nCCCCTC\nCCCCTG\nCCCCTT\nCCCGAA\nCCCGAC\nCCCGAG\nCCCGAT\nCCCGCA\nCCCGCC\nCCCGCG\nCCCGCT\nCCCGGA\nCCCGGC\nCCCGGG\nCCCGGT\nCCCGTA\nCCCGTC\nCCCGTG\nCCCGTT\nCCCTAA\nCCCTAC\nCCCTAG\nCCCTAT\nCCCTCA\nCCCTCC\nCCCTCG\nCCCTCT\nCCCTGA\nCCCTGC\nCCCTGG\nCCCTGT\nCCCTTA\nCCCTTC\nCCCTTG\nCCCTTT\nCCGAAA\nCCGAAC\nCCGAAG\nCCGAAT\nCCGACA\nCCGACC\nCCGACG\nCCGACT\nCCGAGA\nCCGAGC\nCCGAGG\nCCGAGT\nCCGATA\nCCGATC\nCCGATG\nCCGATT\nCCGCAA\nCCGCAC\nCCGCAG\nCCGCAT\nCCGCCA\nCCGCCC\nCCGCCG\nCCGCCT\nCCGCGA\nCCGCGC\nCCGCGG\nCCGCGT\nCCGCTA\nCCGCTC\nCCGCTG\nCCGCTT\nCCGGAA\nCCGGAC\nCCGGAG\nCCGGAT\nCCGGCA\nCCGGCC\nCCGGCG\nCCGGCT\nCCGGGA\nCCGGGC\nCCGGGG\nCCGGGT\nCCGGTA\nCCGGTC\nCCGGTG\nCCGGTT\nCCGTAA\nCCGTAC\nCCGTAG\nCCGTAT\nCCGTCA\nCCGTCC\nCCGTCG\nCCGTCT\nCCGTGA\nCCGTGC\nCCGTGG\nCCGTGT\nCCGTTA\nCCGTTC\nCCGTTG\nCCGTTT\nCCTAAA\nCCTAAC\nCCTAAG\nCCTAAT\nCCTACA\nCCTACC\nCCTACG\nCCTACT\nCCTAGA\nCCTAGC\nCCTAGG\nCCTAGT\nCCTATA\nCCTATC\nCCTATG\nCCTATT\nCCTCAA\nCCTCAC\nCCTCAG\nCCTCAT\nCCTCCA\nCCTCCC\nCCTCCG\nCCTCCT\nCCTCGA\nCCTCGC\nCCTCGG\nCCTCGT\nCCTCTA\nCCTCTC\nCCTCTG\nCCTCTT\nCCTGAA\nCCTGAC\nCCTGAG\nCCTGAT\nCCTGCA\nCCTGCC\nCCTGCG\nCCTGCT\nCCTGGA\nCCTGGC\nCCTGGG\nCCTGGT\nCCTGTA\nCCTGTC\nCCTGTG\nCCTGTT\nCCTTAA\nCCTTAC\nCCTTAG\nCCTTAT\nCCTTCA\nCCTTCC\nCCTTCG\nCCTTCT\nCCTTGA\nCCTTGC\nCCTTGG\nCCTTGT\nCCTTTA\nCCTTTC\nCCTTTG\nCCTTTT\nCGAAAA\nCGAAAC\nCGAAAG\nCGAAAT\nCGAACA\nCGAACC\nCGAACG\nCGAACT\nCGAAGA\nCGAAGC\nCGAAGG\nCGAAGT\nCGAATA\nCGAATC\nCGAATG\nCGAATT\nCGACAA\nCGACAC\nCGACAG\nCGACAT\nCGACCA\nCGACCC\nCGACCG\nCGACCT\nCGACGA\nCGACGC\nCGACGG\nCGACGT\nCGACTA\nCGACTC\nCGACTG\nCGACTT\nCGAGAA\nCGAGAC\nCGAGAG\nCGAGAT\nCGAGCA\nCGAGCC\nCGAGCG\nCGAGCT\nCGAGGA\nCGAGGC\nCGAGGG\nCGAGGT\nCGAGTA\nCGAGTC\nCGAGTG\nCGAGTT\nCGATAA\nCGATAC\nCGATAG\nCGATAT\nCGATCA\nCGATCC\nCGATCG\nCGATCT\nCGATGA\nCGATGC\nCGATGG\nCGATGT\nCGATTA\nCGATTC\nCGATTG\nCGATTT\nCGCAAA\nCGCAAC\nCGCAAG\nCGCAAT\nCGCACA\nCGCACC\nCGCACG\nCGCACT\nCGCAGA\nCGCAGC\nCGCAGG\nCGCAGT\nCGCATA\nCGCATC\nCGCATG\nCGCATT\nCGCCAA\nCGCCAC\nCGCCAG\nCGCCAT\nCGCCCA\nCGCCCC\nCGCCCG\nCGCCCT\nCGCCGA\nCGCCGC\nCGCCGG\nCGCCGT\nCGCCTA\nCGCCTC\nCGCCTG\nCGCCTT\nCGCGAA\nCGCGAC\nCGCGAG\nCGCGAT\nCGCGCA\nCGCGCC\nCGCGCG\nCGCGCT\nCGCGGA\nCGCGGC\nCGCGGG\nCGCGGT\nCGCGTA\nCGCGTC\nCGCGTG\nCGCGTT\nCGCTAA\nCGCTAC\nCGCTAG\nCGCTAT\nCGCTCA\nCGCTCC\nCGCTCG\nCGCTCT\nCGCTGA\nCGCTGC\nCGCTGG\nCGCTGT\nCGCTTA\nCGCTTC\nCGCTTG\nCGCTTT\nCGGAAA\nCGGAAC\nCGGAAG\nCGGAAT\nCGGACA\nCGGACC\nCGGACG\nCGGACT\nCGGAGA\nCGGAGC\nCGGAGG\nCGGAGT\nCGGATA\nCGGATC\nCGGATG\nCGGATT\nCGGCAA\nCGGCAC\nCGGCAG\nCGGCAT\nCGGCCA\nCGGCCC\nCGGCCG\nCGGCCT\nCGGCGA\nCGGCGC\nCGGCGG\nCGGCGT\nCGGCTA\nCGGCTC\nCGGCTG\nCGGCTT\nCGGGAA\nCGGGAC\nCGGGAG\nCGGGAT\nCGGGCA\nCGGGCC\nCGGGCG\nCGGGCT\nCGGGGA\nCGGGGC\nCGGGGG\nCGGGGT\nCGGGTA\nCGGGTC\nCGGGTG\nCGGGTT\nCGGTAA\nCGGTAC\nCGGTAG\nCGGTAT\nCGGTCA\nCGGTCC\nCGGTCG\nCGGTCT\nCGGTGA\nCGGTGC\nCGGTGG\nCGGTGT\nCGGTTA\nCGGTTC\nCGGTTG\nCGGTTT\nCGTAAA\nCGTAAC\nCGTAAG\nCGTAAT\nCGTACA\nCGTACC\nCGTACG\nCGTACT\nCGTAGA\nCGTAGC\nCGTAGG\nCGTAGT\nCGTATA\nCGTATC\nCGTATG\nCGTATT\nCGTCAA\nCGTCAC\nCGTCAG\nCGTCAT\nCGTCCA\nCGTCCC\nCGTCCG\nCGTCCT\nCGTCGA\nCGTCGC\nCGTCGG\nCGTCGT\nCGTCTA\nCGTCTC\nCGTCTG\nCGTCTT\nCGTGAA\nCGTGAC\nCGTGAG\nCGTGAT\nCGTGCA\nCGTGCC\nCGTGCG\nCGTGCT\nCGTGGA\nCGTGGC\nCGTGGG\nCGTGGT\nCGTGTA\nCGTGTC\nCGTGTG\nCGTGTT\nCGTTAA\nCGTTAC\nCGTTAG\nCGTTAT\nCGTTCA\nCGTTCC\nCGTTCG\nCGTTCT\nCGTTGA\nCGTTGC\nCGTTGG\nCGTTGT\nCGTTTA\nCGTTTC\nCGTTTG\nCGTTTT\nCTAAAA\nCTAAAC\nCTAAAG\nCTAAAT\nCTAACA\nCTAACC\nCTAACG\nCTAACT\nCTAAGA\nCTAAGC\nCTAAGG\nCTAAGT\nCTAATA\nCTAATC\nCTAATG\nCTAATT\nCTACAA\nCTACAC\nCTACAG\nCTACAT\nCTACCA\nCTACCC\nCTACCG\nCTACCT\nCTACGA\nCTACGC\nCTACGG\nCTACGT\nCTACTA\nCTACTC\nCTACTG\nCTACTT\nCTAGAA\nCTAGAC\nCTAGAG\nCTAGAT\nCTAGCA\nCTAGCC\nCTAGCG\nCTAGCT\nCTAGGA\nCTAGGC\nCTAGGG\nCTAGGT\nCTAGTA\nCTAGTC\nCTAGTG\nCTAGTT\nCTATAA\nCTATAC\nCTATAG\nCTATAT\nCTATCA\nCTATCC\nCTATCG\nCTATCT\nCTATGA\nCTATGC\nCTATGG\nCTATGT\nCTATTA\nCTATTC\nCTATTG\nCTATTT\nCTCAAA\nCTCAAC\nCTCAAG\nCTCAAT\nCTCACA\nCTCACC\nCTCACG\nCTCACT\nCTCAGA\nCTCAGC\nCTCAGG\nCTCAGT\nCTCATA\nCTCATC\nCTCATG\nCTCATT\nCTCCAA\nCTCCAC\nCTCCAG\nCTCCAT\nCTCCCA\nCTCCCC\nCTCCCG\nCTCCCT\nCTCCGA\nCTCCGC\nCTCCGG\nCTCCGT\nCTCCTA\nCTCCTC\nCTCCTG\nCTCCTT\nCTCGAA\nCTCGAC\nCTCGAG\nCTCGAT\nCTCGCA\nCTCGCC\nCTCGCG\nCTCGCT\nCTCGGA\nCTCGGC\nCTCGGG\nCTCGGT\nCTCGTA\nCTCGTC\nCTCGTG\nCTCGTT\nCTCTAA\nCTCTAC\nCTCTAG\nCTCTAT\nCTCTCA\nCTCTCC\nCTCTCG\nCTCTCT\nCTCTGA\nCTCTGC\nCTCTGG\nCTCTGT\nCTCTTA\nCTCTTC\nCTCTTG\nCTCTTT\nCTGAAA\nCTGAAC\nCTGAAG\nCTGAAT\nCTGACA\nCTGACC\nCTGACG\nCTGACT\nCTGAGA\nCTGAGC\nCTGAGG\nCTGAGT\nCTGATA\nCTGATC\nCTGATG\nCTGATT\nCTGCAA\nCTGCAC\nCTGCAG\nCTGCAT\nCTGCCA\nCTGCCC\nCTGCCG\nCTGCCT\nCTGCGA\nCTGCGC\nCTGCGG\nCTGCGT\nCTGCTA\nCTGCTC\nCTGCTG\nCTGCTT\nCTGGAA\nCTGGAC\nCTGGAG\nCTGGAT\nCTGGCA\nCTGGCC\nCTGGCG\nCTGGCT\nCTGGGA\nCTGGGC\nCTGGGG\nCTGGGT\nCTGGTA\nCTGGTC\nCTGGTG\nCTGGTT\nCTGTAA\nCTGTAC\nCTGTAG\nCTGTAT\nCTGTCA\nCTGTCC\nCTGTCG\nCTGTCT\nCTGTGA\nCTGTGC\nCTGTGG\nCTGTGT\nCTGTTA\nCTGTTC\nCTGTTG\nCTGTTT\nCTTAAA\nCTTAAC\nCTTAAG\nCTTAAT\nCTTACA\nCTTACC\nCTTACG\nCTTACT\nCTTAGA\nCTTAGC\nCTTAGG\nCTTAGT\nCTTATA\nCTTATC\nCTTATG\nCTTATT\nCTTCAA\nCTTCAC\nCTTCAG\nCTTCAT\nCTTCCA\nCTTCCC\nCTTCCG\nCTTCCT\nCTTCGA\nCTTCGC\nCTTCGG\nCTTCGT\nCTTCTA\nCTTCTC\nCTTCTG\nCTTCTT\nCTTGAA\nCTTGAC\nCTTGAG\nCTTGAT\nCTTGCA\nCTTGCC\nCTTGCG\nCTTGCT\nCTTGGA\nCTTGGC\nCTTGGG\nCTTGGT\nCTTGTA\nCTTGTC\nCTTGTG\nCTTGTT\nCTTTAA\nCTTTAC\nCTTTAG\nCTTTAT\nCTTTCA\nCTTTCC\nCTTTCG\nCTTTCT\nCTTTGA\nCTTTGC\nCTTTGG\nCTTTGT\nCTTTTA\nCTTTTC\nCTTTTG\nCTTTTT\nGAAAAA\nGAAAAC\nGAAAAG\nGAAAAT\nGAAACA\nGAAACC\nGAAACG\nGAAACT\nGAAAGA\nGAAAGC\nGAAAGG\nGAAAGT\nGAAATA\nGAAATC\nGAAATG\nGAAATT\nGAACAA\nGAACAC\nGAACAG\nGAACAT\nGAACCA\nGAACCC\nGAACCG\nGAACCT\nGAACGA\nGAACGC\nGAACGG\nGAACGT\nGAACTA\nGAACTC\nGAACTG\nGAACTT\nGAAGAA\nGAAGAC\nGAAGAG\nGAAGAT\nGAAGCA\nGAAGCC\nGAAGCG\nGAAGCT\nGAAGGA\nGAAGGC\nGAAGGG\nGAAGGT\nGAAGTA\nGAAGTC\nGAAGTG\nGAAGTT\nGAATAA\nGAATAC\nGAATAG\nGAATAT\nGAATCA\nGAATCC\nGAATCG\nGAATCT\nGAATGA\nGAATGC\nGAATGG\nGAATGT\nGAATTA\nGAATTC\nGAATTG\nGAATTT\nGACAAA\nGACAAC\nGACAAG\nGACAAT\nGACACA\nGACACC\nGACACG\nGACACT\nGACAGA\nGACAGC\nGACAGG\nGACAGT\nGACATA\nGACATC\nGACATG\nGACATT\nGACCAA\nGACCAC\nGACCAG\nGACCAT\nGACCCA\nGACCCC\nGACCCG\nGACCCT\nGACCGA\nGACCGC\nGACCGG\nGACCGT\nGACCTA\nGACCTC\nGACCTG\nGACCTT\nGACGAA\nGACGAC\nGACGAG\nGACGAT\nGACGCA\nGACGCC\nGACGCG\nGACGCT\nGACGGA\nGACGGC\nGACGGG\nGACGGT\nGACGTA\nGACGTC\nGACGTG\nGACGTT\nGACTAA\nGACTAC\nGACTAG\nGACTAT\nGACTCA\nGACTCC\nGACTCG\nGACTCT\nGACTGA\nGACTGC\nGACTGG\nGACTGT\nGACTTA\nGACTTC\nGACTTG\nGACTTT\nGAGAAA\nGAGAAC\nGAGAAG\nGAGAAT\nGAGACA\nGAGACC\nGAGACG\nGAGACT\nGAGAGA\nGAGAGC\nGAGAGG\nGAGAGT\nGAGATA\nGAGATC\nGAGATG\nGAGATT\nGAGCAA\nGAGCAC\nGAGCAG\nGAGCAT\nGAGCCA\nGAGCCC\nGAGCCG\nGAGCCT\nGAGCGA\nGAGCGC\nGAGCGG\nGAGCGT\nGAGCTA\nGAGCTC\nGAGCTG\nGAGCTT\nGAGGAA\nGAGGAC\nGAGGAG\nGAGGAT\nGAGGCA\nGAGGCC\nGAGGCG\nGAGGCT\nGAGGGA\nGAGGGC\nGAGGGG\nGAGGGT\nGAGGTA\nGAGGTC\nGAGGTG\nGAGGTT\nGAGTAA\nGAGTAC\nGAGTAG\nGAGTAT\nGAGTCA\nGAGTCC\nGAGTCG\nGAGTCT\nGAGTGA\nGAGTGC\nGAGTGG\nGAGTGT\nGAGTTA\nGAGTTC\nGAGTTG\nGAGTTT\nGATAAA\nGATAAC\nGATAAG\nGATAAT\nGATACA\nGATACC\nGATACG\nGATACT\nGATAGA\nGATAGC\nGATAGG\nGATAGT\nGATATA\nGATATC\nGATATG\nGATATT\nGATCAA\nGATCAC\nGATCAG\nGATCAT\nGATCCA\nGATCCC\nGATCCG\nGATCCT\nGATCGA\nGATCGC\nGATCGG\nGATCGT\nGATCTA\nGATCTC\nGATCTG\nGATCTT\nGATGAA\nGATGAC\nGATGAG\nGATGAT\nGATGCA\nGATGCC\nGATGCG\nGATGCT\nGATGGA\nGATGGC\nGATGGG\nGATGGT\nGATGTA\nGATGTC\nGATGTG\nGATGTT\nGATTAA\nGATTAC\nGATTAG\nGATTAT\nGATTCA\nGATTCC\nGATTCG\nGATTCT\nGATTGA\nGATTGC\nGATTGG\nGATTGT\nGATTTA\nGATTTC\nGATTTG\nGATTTT\nGCAAAA\nGCAAAC\nGCAAAG\nGCAAAT\nGCAACA\nGCAACC\nGCAACG\nGCAACT\nGCAAGA\nGCAAGC\nGCAAGG\nGCAAGT\nGCAATA\nGCAATC\nGCAATG\nGCAATT\nGCACAA\nGCACAC\nGCACAG\nGCACAT\nGCACCA\nGCACCC\nGCACCG\nGCACCT\nGCACGA\nGCACGC\nGCACGG\nGCACGT\nGCACTA\nGCACTC\nGCACTG\nGCACTT\nGCAGAA\nGCAGAC\nGCAGAG\nGCAGAT\nGCAGCA\nGCAGCC\nGCAGCG\nGCAGCT\nGCAGGA\nGCAGGC\nGCAGGG\nGCAGGT\nGCAGTA\nGCAGTC\nGCAGTG\nGCAGTT\nGCATAA\nGCATAC\nGCATAG\nGCATAT\nGCATCA\nGCATCC\nGCATCG\nGCATCT\nGCATGA\nGCATGC\nGCATGG\nGCATGT\nGCATTA\nGCATTC\nGCATTG\nGCATTT\nGCCAAA\nGCCAAC\nGCCAAG\nGCCAAT\nGCCACA\nGCCACC\nGCCACG\nGCCACT\nGCCAGA\nGCCAGC\nGCCAGG\nGCCAGT\nGCCATA\nGCCATC\nGCCATG\nGCCATT\nGCCCAA\nGCCCAC\nGCCCAG\nGCCCAT\nGCCCCA\nGCCCCC\nGCCCCG\nGCCCCT\nGCCCGA\nGCCCGC\nGCCCGG\nGCCCGT\nGCCCTA\nGCCCTC\nGCCCTG\nGCCCTT\nGCCGAA\nGCCGAC\nGCCGAG\nGCCGAT\nGCCGCA\nGCCGCC\nGCCGCG\nGCCGCT\nGCCGGA\nGCCGGC\nGCCGGG\nGCCGGT\nGCCGTA\nGCCGTC\nGCCGTG\nGCCGTT\nGCCTAA\nGCCTAC\nGCCTAG\nGCCTAT\nGCCTCA\nGCCTCC\nGCCTCG\nGCCTCT\nGCCTGA\nGCCTGC\nGCCTGG\nGCCTGT\nGCCTTA\nGCCTTC\nGCCTTG\nGCCTTT\nGCGAAA\nGCGAAC\nGCGAAG\nGCGAAT\nGCGACA\nGCGACC\nGCGACG\nGCGACT\nGCGAGA\nGCGAGC\nGCGAGG\nGCGAGT\nGCGATA\nGCGATC\nGCGATG\nGCGATT\nGCGCAA\nGCGCAC\nGCGCAG\nGCGCAT\nGCGCCA\nGCGCCC\nGCGCCG\nGCGCCT\nGCGCGA\nGCGCGC\nGCGCGG\nGCGCGT\nGCGCTA\nGCGCTC\nGCGCTG\nGCGCTT\nGCGGAA\nGCGGAC\nGCGGAG\nGCGGAT\nGCGGCA\nGCGGCC\nGCGGCG\nGCGGCT\nGCGGGA\nGCGGGC\nGCGGGG\nGCGGGT\nGCGGTA\nGCGGTC\nGCGGTG\nGCGGTT\nGCGTAA\nGCGTAC\nGCGTAG\nGCGTAT\nGCGTCA\nGCGTCC\nGCGTCG\nGCGTCT\nGCGTGA\nGCGTGC\nGCGTGG\nGCGTGT\nGCGTTA\nGCGTTC\nGCGTTG\nGCGTTT\nGCTAAA\nGCTAAC\nGCTAAG\nGCTAAT\nGCTACA\nGCTACC\nGCTACG\nGCTACT\nGCTAGA\nGCTAGC\nGCTAGG\nGCTAGT\nGCTATA\nGCTATC\nGCTATG\nGCTATT\nGCTCAA\nGCTCAC\nGCTCAG\nGCTCAT\nGCTCCA\nGCTCCC\nGCTCCG\nGCTCCT\nGCTCGA\nGCTCGC\nGCTCGG\nGCTCGT\nGCTCTA\nGCTCTC\nGCTCTG\nGCTCTT\nGCTGAA\nGCTGAC\nGCTGAG\nGCTGAT\nGCTGCA\nGCTGCC\nGCTGCG\nGCTGCT\nGCTGGA\nGCTGGC\nGCTGGG\nGCTGGT\nGCTGTA\nGCTGTC\nGCTGTG\nGCTGTT\nGCTTAA\nGCTTAC\nGCTTAG\nGCTTAT\nGCTTCA\nGCTTCC\nGCTTCG\nGCTTCT\nGCTTGA\nGCTTGC\nGCTTGG\nGCTTGT\nGCTTTA\nGCTTTC\nGCTTTG\nGCTTTT\nGGAAAA\nGGAAAC\nGGAAAG\nGGAAAT\nGGAACA\nGGAACC\nGGAACG\nGGAACT\nGGAAGA\nGGAAGC\nGGAAGG\nGGAAGT\nGGAATA\nGGAATC\nGGAATG\nGGAATT\nGGACAA\nGGACAC\nGGACAG\nGGACAT\nGGACCA\nGGACCC\nGGACCG\nGGACCT\nGGACGA\nGGACGC\nGGACGG\nGGACGT\nGGACTA\nGGACTC\nGGACTG\nGGACTT\nGGAGAA\nGGAGAC\nGGAGAG\nGGAGAT\nGGAGCA\nGGAGCC\nGGAGCG\nGGAGCT\nGGAGGA\nGGAGGC\nGGAGGG\nGGAGGT\nGGAGTA\nGGAGTC\nGGAGTG\nGGAGTT\nGGATAA\nGGATAC\nGGATAG\nGGATAT\nGGATCA\nGGATCC\nGGATCG\nGGATCT\nGGATGA\nGGATGC\nGGATGG\nGGATGT\nGGATTA\nGGATTC\nGGATTG\nGGATTT\nGGCAAA\nGGCAAC\nGGCAAG\nGGCAAT\nGGCACA\nGGCACC\nGGCACG\nGGCACT\nGGCAGA\nGGCAGC\nGGCAGG\nGGCAGT\nGGCATA\nGGCATC\nGGCATG\nGGCATT\nGGCCAA\nGGCCAC\nGGCCAG\nGGCCAT\nGGCCCA\nGGCCCC\nGGCCCG\nGGCCCT\nGGCCGA\nGGCCGC\nGGCCGG\nGGCCGT\nGGCCTA\nGGCCTC\nGGCCTG\nGGCCTT\nGGCGAA\nGGCGAC\nGGCGAG\nGGCGAT\nGGCGCA\nGGCGCC\nGGCGCG\nGGCGCT\nGGCGGA\nGGCGGC\nGGCGGG\nGGCGGT\nGGCGTA\nGGCGTC\nGGCGTG\nGGCGTT\nGGCTAA\nGGCTAC\nGGCTAG\nGGCTAT\nGGCTCA\nGGCTCC\nGGCTCG\nGGCTCT\nGGCTGA\nGGCTGC\nGGCTGG\nGGCTGT\nGGCTTA\nGGCTTC\nGGCTTG\nGGCTTT\nGGGAAA\nGGGAAC\nGGGAAG\nGGGAAT\nGGGACA\nGGGACC\nGGGACG\nGGGACT\nGGGAGA\nGGGAGC\nGGGAGG\nGGGAGT\nGGGATA\nGGGATC\nGGGATG\nGGGATT\nGGGCAA\nGGGCAC\nGGGCAG\nGGGCAT\nGGGCCA\nGGGCCC\nGGGCCG\nGGGCCT\nGGGCGA\nGGGCGC\nGGGCGG\nGGGCGT\nGGGCTA\nGGGCTC\nGGGCTG\nGGGCTT\nGGGGAA\nGGGGAC\nGGGGAG\nGGGGAT\nGGGGCA\nGGGGCC\nGGGGCG\nGGGGCT\nGGGGGA\nGGGGGC\nGGGGGG\nGGGGGT\nGGGGTA\nGGGGTC\nGGGGTG\nGGGGTT\nGGGTAA\nGGGTAC\nGGGTAG\nGGGTAT\nGGGTCA\nGGGTCC\nGGGTCG\nGGGTCT\nGGGTGA\nGGGTGC\nGGGTGG\nGGGTGT\nGGGTTA\nGGGTTC\nGGGTTG\nGGGTTT\nGGTAAA\nGGTAAC\nGGTAAG\nGGTAAT\nGGTACA\nGGTACC\nGGTACG\nGGTACT\nGGTAGA\nGGTAGC\nGGTAGG\nGGTAGT\nGGTATA\nGGTATC\nGGTATG\nGGTATT\nGGTCAA\nGGTCAC\nGGTCAG\nGGTCAT\nGGTCCA\nGGTCCC\nGGTCCG\nGGTCCT\nGGTCGA\nGGTCGC\nGGTCGG\nGGTCGT\nGGTCTA\nGGTCTC\nGGTCTG\nGGTCTT\nGGTGAA\nGGTGAC\nGGTGAG\nGGTGAT\nGGTGCA\nGGTGCC\nGGTGCG\nGGTGCT\nGGTGGA\nGGTGGC\nGGTGGG\nGGTGGT\nGGTGTA\nGGTGTC\nGGTGTG\nGGTGTT\nGGTTAA\nGGTTAC\nGGTTAG\nGGTTAT\nGGTTCA\nGGTTCC\nGGTTCG\nGGTTCT\nGGTTGA\nGGTTGC\nGGTTGG\nGGTTGT\nGGTTTA\nGGTTTC\nGGTTTG\nGGTTTT\nGTAAAA\nGTAAAC\nGTAAAG\nGTAAAT\nGTAACA\nGTAACC\nGTAACG\nGTAACT\nGTAAGA\nGTAAGC\nGTAAGG\nGTAAGT\nGTAATA\nGTAATC\nGTAATG\nGTAATT\nGTACAA\nGTACAC\nGTACAG\nGTACAT\nGTACCA\nGTACCC\nGTACCG\nGTACCT\nGTACGA\nGTACGC\nGTACGG\nGTACGT\nGTACTA\nGTACTC\nGTACTG\nGTACTT\nGTAGAA\nGTAGAC\nGTAGAG\nGTAGAT\nGTAGCA\nGTAGCC\nGTAGCG\nGTAGCT\nGTAGGA\nGTAGGC\nGTAGGG\nGTAGGT\nGTAGTA\nGTAGTC\nGTAGTG\nGTAGTT\nGTATAA\nGTATAC\nGTATAG\nGTATAT\nGTATCA\nGTATCC\nGTATCG\nGTATCT\nGTATGA\nGTATGC\nGTATGG\nGTATGT\nGTATTA\nGTATTC\nGTATTG\nGTATTT\nGTCAAA\nGTCAAC\nGTCAAG\nGTCAAT\nGTCACA\nGTCACC\nGTCACG\nGTCACT\nGTCAGA\nGTCAGC\nGTCAGG\nGTCAGT\nGTCATA\nGTCATC\nGTCATG\nGTCATT\nGTCCAA\nGTCCAC\nGTCCAG\nGTCCAT\nGTCCCA\nGTCCCC\nGTCCCG\nGTCCCT\nGTCCGA\nGTCCGC\nGTCCGG\nGTCCGT\nGTCCTA\nGTCCTC\nGTCCTG\nGTCCTT\nGTCGAA\nGTCGAC\nGTCGAG\nGTCGAT\nGTCGCA\nGTCGCC\nGTCGCG\nGTCGCT\nGTCGGA\nGTCGGC\nGTCGGG\nGTCGGT\nGTCGTA\nGTCGTC\nGTCGTG\nGTCGTT\nGTCTAA\nGTCTAC\nGTCTAG\nGTCTAT\nGTCTCA\nGTCTCC\nGTCTCG\nGTCTCT\nGTCTGA\nGTCTGC\nGTCTGG\nGTCTGT\nGTCTTA\nGTCTTC\nGTCTTG\nGTCTTT\nGTGAAA\nGTGAAC\nGTGAAG\nGTGAAT\nGTGACA\nGTGACC\nGTGACG\nGTGACT\nGTGAGA\nGTGAGC\nGTGAGG\nGTGAGT\nGTGATA\nGTGATC\nGTGATG\nGTGATT\nGTGCAA\nGTGCAC\nGTGCAG\nGTGCAT\nGTGCCA\nGTGCCC\nGTGCCG\nGTGCCT\nGTGCGA\nGTGCGC\nGTGCGG\nGTGCGT\nGTGCTA\nGTGCTC\nGTGCTG\nGTGCTT\nGTGGAA\nGTGGAC\nGTGGAG\nGTGGAT\nGTGGCA\nGTGGCC\nGTGGCG\nGTGGCT\nGTGGGA\nGTGGGC\nGTGGGG\nGTGGGT\nGTGGTA\nGTGGTC\nGTGGTG\nGTGGTT\nGTGTAA\nGTGTAC\nGTGTAG\nGTGTAT\nGTGTCA\nGTGTCC\nGTGTCG\nGTGTCT\nGTGTGA\nGTGTGC\nGTGTGG\nGTGTGT\nGTGTTA\nGTGTTC\nGTGTTG\nGTGTTT\nGTTAAA\nGTTAAC\nGTTAAG\nGTTAAT\nGTTACA\nGTTACC\nGTTACG\nGTTACT\nGTTAGA\nGTTAGC\nGTTAGG\nGTTAGT\nGTTATA\nGTTATC\nGTTATG\nGTTATT\nGTTCAA\nGTTCAC\nGTTCAG\nGTTCAT\nGTTCCA\nGTTCCC\nGTTCCG\nGTTCCT\nGTTCGA\nGTTCGC\nGTTCGG\nGTTCGT\nGTTCTA\nGTTCTC\nGTTCTG\nGTTCTT\nGTTGAA\nGTTGAC\nGTTGAG\nGTTGAT\nGTTGCA\nGTTGCC\nGTTGCG\nGTTGCT\nGTTGGA\nGTTGGC\nGTTGGG\nGTTGGT\nGTTGTA\nGTTGTC\nGTTGTG\nGTTGTT\nGTTTAA\nGTTTAC\nGTTTAG\nGTTTAT\nGTTTCA\nGTTTCC\nGTTTCG\nGTTTCT\nGTTTGA\nGTTTGC\nGTTTGG\nGTTTGT\nGTTTTA\nGTTTTC\nGTTTTG\nGTTTTT\nTAAAAA\nTAAAAC\nTAAAAG\nTAAAAT\nTAAACA\nTAAACC\nTAAACG\nTAAACT\nTAAAGA\nTAAAGC\nTAAAGG\nTAAAGT\nTAAATA\nTAAATC\nTAAATG\nTAAATT\nTAACAA\nTAACAC\nTAACAG\nTAACAT\nTAACCA\nTAACCC\nTAACCG\nTAACCT\nTAACGA\nTAACGC\nTAACGG\nTAACGT\nTAACTA\nTAACTC\nTAACTG\nTAACTT\nTAAGAA\nTAAGAC\nTAAGAG\nTAAGAT\nTAAGCA\nTAAGCC\nTAAGCG\nTAAGCT\nTAAGGA\nTAAGGC\nTAAGGG\nTAAGGT\nTAAGTA\nTAAGTC\nTAAGTG\nTAAGTT\nTAATAA\nTAATAC\nTAATAG\nTAATAT\nTAATCA\nTAATCC\nTAATCG\nTAATCT\nTAATGA\nTAATGC\nTAATGG\nTAATGT\nTAATTA\nTAATTC\nTAATTG\nTAATTT\nTACAAA\nTACAAC\nTACAAG\nTACAAT\nTACACA\nTACACC\nTACACG\nTACACT\nTACAGA\nTACAGC\nTACAGG\nTACAGT\nTACATA\nTACATC\nTACATG\nTACATT\nTACCAA\nTACCAC\nTACCAG\nTACCAT\nTACCCA\nTACCCC\nTACCCG\nTACCCT\nTACCGA\nTACCGC\nTACCGG\nTACCGT\nTACCTA\nTACCTC\nTACCTG\nTACCTT\nTACGAA\nTACGAC\nTACGAG\nTACGAT\nTACGCA\nTACGCC\nTACGCG\nTACGCT\nTACGGA\nTACGGC\nTACGGG\nTACGGT\nTACGTA\nTACGTC\nTACGTG\nTACGTT\nTACTAA\nTACTAC\nTACTAG\nTACTAT\nTACTCA\nTACTCC\nTACTCG\nTACTCT\nTACTGA\nTACTGC\nTACTGG\nTACTGT\nTACTTA\nTACTTC\nTACTTG\nTACTTT\nTAGAAA\nTAGAAC\nTAGAAG\nTAGAAT\nTAGACA\nTAGACC\nTAGACG\nTAGACT\nTAGAGA\nTAGAGC\nTAGAGG\nTAGAGT\nTAGATA\nTAGATC\nTAGATG\nTAGATT\nTAGCAA\nTAGCAC\nTAGCAG\nTAGCAT\nTAGCCA\nTAGCCC\nTAGCCG\nTAGCCT\nTAGCGA\nTAGCGC\nTAGCGG\nTAGCGT\nTAGCTA\nTAGCTC\nTAGCTG\nTAGCTT\nTAGGAA\nTAGGAC\nTAGGAG\nTAGGAT\nTAGGCA\nTAGGCC\nTAGGCG\nTAGGCT\nTAGGGA\nTAGGGC\nTAGGGG\nTAGGGT\nTAGGTA\nTAGGTC\nTAGGTG\nTAGGTT\nTAGTAA\nTAGTAC\nTAGTAG\nTAGTAT\nTAGTCA\nTAGTCC\nTAGTCG\nTAGTCT\nTAGTGA\nTAGTGC\nTAGTGG\nTAGTGT\nTAGTTA\nTAGTTC\nTAGTTG\nTAGTTT\nTATAAA\nTATAAC\nTATAAG\nTATAAT\nTATACA\nTATACC\nTATACG\nTATACT\nTATAGA\nTATAGC\nTATAGG\nTATAGT\nTATATA\nTATATC\nTATATG\nTATATT\nTATCAA\nTATCAC\nTATCAG\nTATCAT\nTATCCA\nTATCCC\nTATCCG\nTATCCT\nTATCGA\nTATCGC\nTATCGG\nTATCGT\nTATCTA\nTATCTC\nTATCTG\nTATCTT\nTATGAA\nTATGAC\nTATGAG\nTATGAT\nTATGCA\nTATGCC\nTATGCG\nTATGCT\nTATGGA\nTATGGC\nTATGGG\nTATGGT\nTATGTA\nTATGTC\nTATGTG\nTATGTT\nTATTAA\nTATTAC\nTATTAG\nTATTAT\nTATTCA\nTATTCC\nTATTCG\nTATTCT\nTATTGA\nTATTGC\nTATTGG\nTATTGT\nTATTTA\nTATTTC\nTATTTG\nTATTTT\nTCAAAA\nTCAAAC\nTCAAAG\nTCAAAT\nTCAACA\nTCAACC\nTCAACG\nTCAACT\nTCAAGA\nTCAAGC\nTCAAGG\nTCAAGT\nTCAATA\nTCAATC\nTCAATG\nTCAATT\nTCACAA\nTCACAC\nTCACAG\nTCACAT\nTCACCA\nTCACCC\nTCACCG\nTCACCT\nTCACGA\nTCACGC\nTCACGG\nTCACGT\nTCACTA\nTCACTC\nTCACTG\nTCACTT\nTCAGAA\nTCAGAC\nTCAGAG\nTCAGAT\nTCAGCA\nTCAGCC\nTCAGCG\nTCAGCT\nTCAGGA\nTCAGGC\nTCAGGG\nTCAGGT\nTCAGTA\nTCAGTC\nTCAGTG\nTCAGTT\nTCATAA\nTCATAC\nTCATAG\nTCATAT\nTCATCA\nTCATCC\nTCATCG\nTCATCT\nTCATGA\nTCATGC\nTCATGG\nTCATGT\nTCATTA\nTCATTC\nTCATTG\nTCATTT\nTCCAAA\nTCCAAC\nTCCAAG\nTCCAAT\nTCCACA\nTCCACC\nTCCACG\nTCCACT\nTCCAGA\nTCCAGC\nTCCAGG\nTCCAGT\nTCCATA\nTCCATC\nTCCATG\nTCCATT\nTCCCAA\nTCCCAC\nTCCCAG\nTCCCAT\nTCCCCA\nTCCCCC\nTCCCCG\nTCCCCT\nTCCCGA\nTCCCGC\nTCCCGG\nTCCCGT\nTCCCTA\nTCCCTC\nTCCCTG\nTCCCTT\nTCCGAA\nTCCGAC\nTCCGAG\nTCCGAT\nTCCGCA\nTCCGCC\nTCCGCG\nTCCGCT\nTCCGGA\nTCCGGC\nTCCGGG\nTCCGGT\nTCCGTA\nTCCGTC\nTCCGTG\nTCCGTT\nTCCTAA\nTCCTAC\nTCCTAG\nTCCTAT\nTCCTCA\nTCCTCC\nTCCTCG\nTCCTCT\nTCCTGA\nTCCTGC\nTCCTGG\nTCCTGT\nTCCTTA\nTCCTTC\nTCCTTG\nTCCTTT\nTCGAAA\nTCGAAC\nTCGAAG\nTCGAAT\nTCGACA\nTCGACC\nTCGACG\nTCGACT\nTCGAGA\nTCGAGC\nTCGAGG\nTCGAGT\nTCGATA\nTCGATC\nTCGATG\nTCGATT\nTCGCAA\nTCGCAC\nTCGCAG\nTCGCAT\nTCGCCA\nTCGCCC\nTCGCCG\nTCGCCT\nTCGCGA\nTCGCGC\nTCGCGG\nTCGCGT\nTCGCTA\nTCGCTC\nTCGCTG\nTCGCTT\nTCGGAA\nTCGGAC\nTCGGAG\nTCGGAT\nTCGGCA\nTCGGCC\nTCGGCG\nTCGGCT\nTCGGGA\nTCGGGC\nTCGGGG\nTCGGGT\nTCGGTA\nTCGGTC\nTCGGTG\nTCGGTT\nTCGTAA\nTCGTAC\nTCGTAG\nTCGTAT\nTCGTCA\nTCGTCC\nTCGTCG\nTCGTCT\nTCGTGA\nTCGTGC\nTCGTGG\nTCGTGT\nTCGTTA\nTCGTTC\nTCGTTG\nTCGTTT\nTCTAAA\nTCTAAC\nTCTAAG\nTCTAAT\nTCTACA\nTCTACC\nTCTACG\nTCTACT\nTCTAGA\nTCTAGC\nTCTAGG\nTCTAGT\nTCTATA\nTCTATC\nTCTATG\nTCTATT\nTCTCAA\nTCTCAC\nTCTCAG\nTCTCAT\nTCTCCA\nTCTCCC\nTCTCCG\nTCTCCT\nTCTCGA\nTCTCGC\nTCTCGG\nTCTCGT\nTCTCTA\nTCTCTC\nTCTCTG\nTCTCTT\nTCTGAA\nTCTGAC\nTCTGAG\nTCTGAT\nTCTGCA\nTCTGCC\nTCTGCG\nTCTGCT\nTCTGGA\nTCTGGC\nTCTGGG\nTCTGGT\nTCTGTA\nTCTGTC\nTCTGTG\nTCTGTT\nTCTTAA\nTCTTAC\nTCTTAG\nTCTTAT\nTCTTCA\nTCTTCC\nTCTTCG\nTCTTCT\nTCTTGA\nTCTTGC\nTCTTGG\nTCTTGT\nTCTTTA\nTCTTTC\nTCTTTG\nTCTTTT\nTGAAAA\nTGAAAC\nTGAAAG\nTGAAAT\nTGAACA\nTGAACC\nTGAACG\nTGAACT\nTGAAGA\nTGAAGC\nTGAAGG\nTGAAGT\nTGAATA\nTGAATC\nTGAATG\nTGAATT\nTGACAA\nTGACAC\nTGACAG\nTGACAT\nTGACCA\nTGACCC\nTGACCG\nTGACCT\nTGACGA\nTGACGC\nTGACGG\nTGACGT\nTGACTA\nTGACTC\nTGACTG\nTGACTT\nTGAGAA\nTGAGAC\nTGAGAG\nTGAGAT\nTGAGCA\nTGAGCC\nTGAGCG\nTGAGCT\nTGAGGA\nTGAGGC\nTGAGGG\nTGAGGT\nTGAGTA\nTGAGTC\nTGAGTG\nTGAGTT\nTGATAA\nTGATAC\nTGATAG\nTGATAT\nTGATCA\nTGATCC\nTGATCG\nTGATCT\nTGATGA\nTGATGC\nTGATGG\nTGATGT\nTGATTA\nTGATTC\nTGATTG\nTGATTT\nTGCAAA\nTGCAAC\nTGCAAG\nTGCAAT\nTGCACA\nTGCACC\nTGCACG\nTGCACT\nTGCAGA\nTGCAGC\nTGCAGG\nTGCAGT\nTGCATA\nTGCATC\nTGCATG\nTGCATT\nTGCCAA\nTGCCAC\nTGCCAG\nTGCCAT\nTGCCCA\nTGCCCC\nTGCCCG\nTGCCCT\nTGCCGA\nTGCCGC\nTGCCGG\nTGCCGT\nTGCCTA\nTGCCTC\nTGCCTG\nTGCCTT\nTGCGAA\nTGCGAC\nTGCGAG\nTGCGAT\nTGCGCA\nTGCGCC\nTGCGCG\nTGCGCT\nTGCGGA\nTGCGGC\nTGCGGG\nTGCGGT\nTGCGTA\nTGCGTC\nTGCGTG\nTGCGTT\nTGCTAA\nTGCTAC\nTGCTAG\nTGCTAT\nTGCTCA\nTGCTCC\nTGCTCG\nTGCTCT\nTGCTGA\nTGCTGC\nTGCTGG\nTGCTGT\nTGCTTA\nTGCTTC\nTGCTTG\nTGCTTT\nTGGAAA\nTGGAAC\nTGGAAG\nTGGAAT\nTGGACA\nTGGACC\nTGGACG\nTGGACT\nTGGAGA\nTGGAGC\nTGGAGG\nTGGAGT\nTGGATA\nTGGATC\nTGGATG\nTGGATT\nTGGCAA\nTGGCAC\nTGGCAG\nTGGCAT\nTGGCCA\nTGGCCC\nTGGCCG\nTGGCCT\nTGGCGA\nTGGCGC\nTGGCGG\nTGGCGT\nTGGCTA\nTGGCTC\nTGGCTG\nTGGCTT\nTGGGAA\nTGGGAC\nTGGGAG\nTGGGAT\nTGGGCA\nTGGGCC\nTGGGCG\nTGGGCT\nTGGGGA\nTGGGGC\nTGGGGG\nTGGGGT\nTGGGTA\nTGGGTC\nTGGGTG\nTGGGTT\nTGGTAA\nTGGTAC\nTGGTAG\nTGGTAT\nTGGTCA\nTGGTCC\nTGGTCG\nTGGTCT\nTGGTGA\nTGGTGC\nTGGTGG\nTGGTGT\nTGGTTA\nTGGTTC\nTGGTTG\nTGGTTT\nTGTAAA\nTGTAAC\nTGTAAG\nTGTAAT\nTGTACA\nTGTACC\nTGTACG\nTGTACT\nTGTAGA\nTGTAGC\nTGTAGG\nTGTAGT\nTGTATA\nTGTATC\nTGTATG\nTGTATT\nTGTCAA\nTGTCAC\nTGTCAG\nTGTCAT\nTGTCCA\nTGTCCC\nTGTCCG\nTGTCCT\nTGTCGA\nTGTCGC\nTGTCGG\nTGTCGT\nTGTCTA\nTGTCTC\nTGTCTG\nTGTCTT\nTGTGAA\nTGTGAC\nTGTGAG\nTGTGAT\nTGTGCA\nTGTGCC\nTGTGCG\nTGTGCT\nTGTGGA\nTGTGGC\nTGTGGG\nTGTGGT\nTGTGTA\nTGTGTC\nTGTGTG\nTGTGTT\nTGTTAA\nTGTTAC\nTGTTAG\nTGTTAT\nTGTTCA\nTGTTCC\nTGTTCG\nTGTTCT\nTGTTGA\nTGTTGC\nTGTTGG\nTGTTGT\nTGTTTA\nTGTTTC\nTGTTTG\nTGTTTT\nTTAAAA\nTTAAAC\nTTAAAG\nTTAAAT\nTTAACA\nTTAACC\nTTAACG\nTTAACT\nTTAAGA\nTTAAGC\nTTAAGG\nTTAAGT\nTTAATA\nTTAATC\nTTAATG\nTTAATT\nTTACAA\nTTACAC\nTTACAG\nTTACAT\nTTACCA\nTTACCC\nTTACCG\nTTACCT\nTTACGA\nTTACGC\nTTACGG\nTTACGT\nTTACTA\nTTACTC\nTTACTG\nTTACTT\nTTAGAA\nTTAGAC\nTTAGAG\nTTAGAT\nTTAGCA\nTTAGCC\nTTAGCG\nTTAGCT\nTTAGGA\nTTAGGC\nTTAGGG\nTTAGGT\nTTAGTA\nTTAGTC\nTTAGTG\nTTAGTT\nTTATAA\nTTATAC\nTTATAG\nTTATAT\nTTATCA\nTTATCC\nTTATCG\nTTATCT\nTTATGA\nTTATGC\nTTATGG\nTTATGT\nTTATTA\nTTATTC\nTTATTG\nTTATTT\nTTCAAA\nTTCAAC\nTTCAAG\nTTCAAT\nTTCACA\nTTCACC\nTTCACG\nTTCACT\nTTCAGA\nTTCAGC\nTTCAGG\nTTCAGT\nTTCATA\nTTCATC\nTTCATG\nTTCATT\nTTCCAA\nTTCCAC\nTTCCAG\nTTCCAT\nTTCCCA\nTTCCCC\nTTCCCG\nTTCCCT\nTTCCGA\nTTCCGC\nTTCCGG\nTTCCGT\nTTCCTA\nTTCCTC\nTTCCTG\nTTCCTT\nTTCGAA\nTTCGAC\nTTCGAG\nTTCGAT\nTTCGCA\nTTCGCC\nTTCGCG\nTTCGCT\nTTCGGA\nTTCGGC\nTTCGGG\nTTCGGT\nTTCGTA\nTTCGTC\nTTCGTG\nTTCGTT\nTTCTAA\nTTCTAC\nTTCTAG\nTTCTAT\nTTCTCA\nTTCTCC\nTTCTCG\nTTCTCT\nTTCTGA\nTTCTGC\nTTCTGG\nTTCTGT\nTTCTTA\nTTCTTC\nTTCTTG\nTTCTTT\nTTGAAA\nTTGAAC\nTTGAAG\nTTGAAT\nTTGACA\nTTGACC\nTTGACG\nTTGACT\nTTGAGA\nTTGAGC\nTTGAGG\nTTGAGT\nTTGATA\nTTGATC\nTTGATG\nTTGATT\nTTGCAA\nTTGCAC\nTTGCAG\nTTGCAT\nTTGCCA\nTTGCCC\nTTGCCG\nTTGCCT\nTTGCGA\nTTGCGC\nTTGCGG\nTTGCGT\nTTGCTA\nTTGCTC\nTTGCTG\nTTGCTT\nTTGGAA\nTTGGAC\nTTGGAG\nTTGGAT\nTTGGCA\nTTGGCC\nTTGGCG\nTTGGCT\nTTGGGA\nTTGGGC\nTTGGGG\nTTGGGT\nTTGGTA\nTTGGTC\nTTGGTG\nTTGGTT\nTTGTAA\nTTGTAC\nTTGTAG\nTTGTAT\nTTGTCA\nTTGTCC\nTTGTCG\nTTGTCT\nTTGTGA\nTTGTGC\nTTGTGG\nTTGTGT\nTTGTTA\nTTGTTC\nTTGTTG\nTTGTTT\nTTTAAA\nTTTAAC\nTTTAAG\nTTTAAT\nTTTACA\nTTTACC\nTTTACG\nTTTACT\nTTTAGA\nTTTAGC\nTTTAGG\nTTTAGT\nTTTATA\nTTTATC\nTTTATG\nTTTATT\nTTTCAA\nTTTCAC\nTTTCAG\nTTTCAT\nTTTCCA\nTTTCCC\nTTTCCG\nTTTCCT\nTTTCGA\nTTTCGC\nTTTCGG\nTTTCGT\nTTTCTA\nTTTCTC\nTTTCTG\nTTTCTT\nTTTGAA\nTTTGAC\nTTTGAG\nTTTGAT\nTTTGCA\nTTTGCC\nTTTGCG\nTTTGCT\nTTTGGA\nTTTGGC\nTTTGGG\nTTTGGT\nTTTGTA\nTTTGTC\nTTTGTG\nTTTGTT\nTTTTAA\nTTTTAC\nTTTTAG\nTTTTAT\nTTTTCA\nTTTTCC\nTTTTCG\nTTTTCT\nTTTTGA\nTTTTGC\nTTTTGG\nTTTTGT\nTTTTTA\nTTTTTC\nTTTTTG\nTTTTTT\nNNNNNN\n