commit 7140e0af74771d332419c64f1ea01689ea05f851 Author: ModelHub XC Date: Sat Jul 25 14:42:11 2026 +0800 初始化项目，由ModelHub XC社区提供模型 Model: DOEJGI/GenomeOcean-4B Source: Original Platform diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..a6344aa --- /dev/null +++ b/.gitattributes @@ -0,0 +1,35 @@ +*.7z filter=lfs diff=lfs merge=lfs -text +*.arrow filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.ckpt filter=lfs diff=lfs merge=lfs -text +*.ftz filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.h5 filter=lfs diff=lfs merge=lfs -text +*.joblib filter=lfs diff=lfs merge=lfs -text +*.lfs.* filter=lfs diff=lfs merge=lfs -text +*.mlmodel filter=lfs diff=lfs merge=lfs -text +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack filter=lfs diff=lfs merge=lfs -text +*.npy filter=lfs diff=lfs merge=lfs -text +*.npz filter=lfs diff=lfs merge=lfs -text +*.onnx filter=lfs diff=lfs merge=lfs -text +*.ot filter=lfs diff=lfs merge=lfs -text +*.parquet filter=lfs diff=lfs merge=lfs -text +*.pb filter=lfs diff=lfs merge=lfs -text +*.pickle filter=lfs diff=lfs merge=lfs -text +*.pkl filter=lfs diff=lfs merge=lfs -text +*.pt filter=lfs diff=lfs merge=lfs -text +*.pth filter=lfs diff=lfs merge=lfs -text +*.rar filter=lfs diff=lfs merge=lfs -text +*.safetensors filter=lfs diff=lfs merge=lfs -text +saved_model/**/* filter=lfs diff=lfs merge=lfs -text +*.tar.* filter=lfs diff=lfs merge=lfs -text +*.tar filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.wasm filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text +*tfevents* filter=lfs diff=lfs merge=lfs -text diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e32abbc --- /dev/null +++ b/LICENSE @@ -0,0 +1,44 @@ +*** License Agreement *** + +genomeocean: a pretrained microbial genome foundational model (genomeoceanLLM) +Copyright (c) 2025, The Regents of the University of California, through Lawrence Berkeley +National Laboratory (subject to receipt of any required approvals from the U.S. Dept. of Energy) +and Northwestern University. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +(1) Redistributions of source code must retain the above copyright notice, +this list of conditions and the following disclaimer. + +(2) Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. + +(3) Neither the name of the University of California, Lawrence Berkeley +National Laboratory, U.S. Dept. of Energy, Northwestern University nor +the names of its contributors may be used to endorse or promote products +derived from this software without specific prior written permission. + + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. +IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT +NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY +OF SUCH DAMAGE. + +You are under no obligation whatsoever to provide any bug fixes, patches, +or upgrades to the features, functionality or performance of the source +code ("Enhancements") to anyone; however, if you choose to make your +Enhancements available either publicly, or directly to Lawrence Berkeley +National Laboratory, without imposing a separate written license agreement +for such Enhancements, then you hereby grant the following license: a +non-exclusive, royalty-free perpetual license to install, use, modify, +prepare derivative works, incorporate into other computer software, +distribute, and sublicense such enhancements or derivative works thereof, +in binary and source code form. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..5c7be7e --- /dev/null +++ b/README.md @@ -0,0 +1,41 @@ +--- +license: bsd +tags: +- biology +- genomics +- metagenomics +- DNA +- microbiome +--- + +This is the base model of GenomeOcean-4B. It is trained with Causal Language Modeling (CLM) and uses a BPE tokenizer with 4096 tokens. It supports a maximum sequence length of 10240 tokens (~50kbp). + +Please see our official implementation on our [Github](https://github.com/jgi-genomeocean/genomeocean). + +Quick start. + +``` +import torch +from transformers import AutoModelForCausalLM, AutoTokenizer + +tokenizer = AutoTokenizer.from_pretrained( + "pGenomeOcean/GenomeOcean-4B", + trust_remote_code=True, + padding_side="left", +) +model = AutoModelForCausalLM.from_pretrained( + "pGenomeOcean/GenomeOcean-4B", + trust_remote_code=True, + torch_dtype=torch.bfloat16, + attn_implementation="flash_attention_2", +).to("cuda") +``` + + +Copyright Notice + +genomeocean: a pretrained microbial genome foundational model (genomeoceanLLM) ” Copyright (c) 2025, The Regents of the University of California, through Lawrence Berkeley National Laboratory (subject to receipt of any required approvals from the U.S. Dept. of Energy) and Northwestern University. All rights reserved. + +If you have questions about your rights to use or distribute this software, please contact Berkeley Lab's Intellectual Property Office at IPO@lbl.gov. + +NOTICE. This Software was developed under funding from the U.S. Department of Energy and the U.S. Government consequently retains certain rights. As such, the U.S. Government has been granted for itself and others acting on its behalf a paid-up, nonexclusive, irrevocable, worldwide license in the Software to reproduce, distribute copies to the public, prepare derivative works, and perform publicly and display publicly, and to permit others to do so. \ No newline at end of file diff --git a/config.json b/config.json new file mode 100644 index 0000000..b2e282e --- /dev/null +++ b/config.json @@ -0,0 +1,38 @@ +{ + "_name_or_path": "/pscratch/sd/z/zhihanz/models/mistral_4B_hmp_frommeta55k/model_meta55k_hmp4k", + "architectures": [ + "MistralForCausalLM" + ], + "attention_dropout": 0.0, + "auto_map": { + "AutoConfig": "configuration_mistral.MistralConfig", + "AutoModel": "modeling_mistral.MistralModel", + "AutoModelForCausalLM": "modeling_mistral.MistralForCausalLM", + "AutoModelForMaskedLM": "modeling_mistral.MistralForMaskedLM", + "AutoModelForSequenceClassification": "modeling_mistral.MistralForSequenceClassification" + }, + "bos_token_id": 1, + "classifier_dropout": 0.1, + "eos_token_id": 2, + "hidden_act": "silu", + "hidden_size": 3072, + "initializer_range": 0.02, + "intermediate_size": 16384, + "is_causal": true, + "max_position_embeddings": 32768, + "model_type": "mistral", + "num_attention_heads": 12, + "num_hidden_layers": 24, + "num_key_value_heads": 4, + "output_router_logits": false, + "pad_token_id": 3, + "rms_norm_eps": 1e-05, + "rope_theta": 1000000.0, + "router_aux_loss_coef": 0.02, + "sliding_window": null, + "tie_word_embeddings": false, + "torch_dtype": "bfloat16", + "transformers_version": "4.38.2", + "use_cache": true, + "vocab_size": 4096 +} diff --git a/configuration_mistral.py b/configuration_mistral.py new file mode 100644 index 0000000..e888c99 --- /dev/null +++ b/configuration_mistral.py @@ -0,0 +1,152 @@ +# coding=utf-8 +# Copyright 2023 Mistral AI and the HuggingFace Inc. team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" Mistral model configuration""" + +from transformers.configuration_utils import PretrainedConfig +from transformers.utils import logging + + +logger = logging.get_logger(__name__) + +MISTRAL_PRETRAINED_CONFIG_ARCHIVE_MAP = { + "mistralai/Mistral-7B-v0.1": "https://huggingface.co/mistralai/Mistral-7B-v0.1/resolve/main/config.json", + "mistralai/Mistral-7B-Instruct-v0.1": "https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.1/resolve/main/config.json", +} + + +class MistralConfig(PretrainedConfig): + r""" + This is the configuration class to store the configuration of a [`MistralModel`]. It is used to instantiate an + Mistral model according to the specified arguments, defining the model architecture. Instantiating a configuration + with the defaults will yield a similar configuration to that of the Mistral-7B-v0.1 or Mistral-7B-Instruct-v0.1. + + [mistralai/Mistral-7B-v0.1](https://huggingface.co/mistralai/Mistral-7B-v0.1) + [mistralai/Mistral-7B-Instruct-v0.1](https://huggingface.co/mistralai/Mistral-7B-Instruct-v0.1) + + Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the + documentation from [`PretrainedConfig`] for more information. + + + Args: + vocab_size (`int`, *optional*, defaults to 32000): + Vocabulary size of the Mistral model. Defines the number of different tokens that can be represented by the + `inputs_ids` passed when calling [`MistralModel`] + hidden_size (`int`, *optional*, defaults to 4096): + Dimension of the hidden representations. + intermediate_size (`int`, *optional*, defaults to 14336): + Dimension of the MLP representations. + num_hidden_layers (`int`, *optional*, defaults to 32): + Number of hidden layers in the Transformer encoder. + num_attention_heads (`int`, *optional*, defaults to 32): + Number of attention heads for each attention layer in the Transformer encoder. + num_key_value_heads (`int`, *optional*, defaults to 8): + This is the number of key_value heads that should be used to implement Grouped Query Attention. If + `num_key_value_heads=num_attention_heads`, the model will use Multi Head Attention (MHA), if + `num_key_value_heads=1 the model will use Multi Query Attention (MQA) otherwise GQA is used. When + converting a multi-head checkpoint to a GQA checkpoint, each group key and value head should be constructed + by meanpooling all the original heads within that group. For more details checkout [this + paper](https://arxiv.org/pdf/2305.13245.pdf). If it is not specified, will default to `8`. + hidden_act (`str` or `function`, *optional*, defaults to `"silu"`): + The non-linear activation function (function or string) in the decoder. + max_position_embeddings (`int`, *optional*, defaults to `4096*32`): + The maximum sequence length that this model might ever be used with. Mistral's sliding window attention + allows sequence of up to 4096*32 tokens. + initializer_range (`float`, *optional*, defaults to 0.02): + The standard deviation of the truncated_normal_initializer for initializing all weight matrices. + rms_norm_eps (`float`, *optional*, defaults to 1e-06): + The epsilon used by the rms normalization layers. + use_cache (`bool`, *optional*, defaults to `True`): + Whether or not the model should return the last key/values attentions (not used by all models). Only + relevant if `config.is_decoder=True`. + pad_token_id (`int`, *optional*): + The id of the padding token. + bos_token_id (`int`, *optional*, defaults to 1): + The id of the "beginning-of-sequence" token. + eos_token_id (`int`, *optional*, defaults to 2): + The id of the "end-of-sequence" token. + tie_word_embeddings (`bool`, *optional*, defaults to `False`): + Whether the model's input and output word embeddings should be tied. + rope_theta (`float`, *optional*, defaults to 10000.0): + The base period of the RoPE embeddings. + sliding_window (`int`, *optional*, defaults to 4096): + Sliding window attention window size. If not specified, will default to `4096`. + attention_dropout (`float`, *optional*, defaults to 0.0): + The dropout ratio for the attention probabilities. + + ```python + >>> from transformers import MistralModel, MistralConfig + + >>> # Initializing a Mistral 7B style configuration + >>> configuration = MistralConfig() + + >>> # Initializing a model from the Mistral 7B style configuration + >>> model = MistralModel(configuration) + + >>> # Accessing the model configuration + >>> configuration = model.config + ```""" + + model_type = "mistral" + keys_to_ignore_at_inference = ["past_key_values"] + + def __init__( + self, + vocab_size=32000, + hidden_size=4096, + intermediate_size=14336, + num_hidden_layers=32, + num_attention_heads=32, + num_key_value_heads=8, + hidden_act="silu", + max_position_embeddings=4096 * 32, + initializer_range=0.02, + rms_norm_eps=1e-6, + use_cache=True, + pad_token_id=None, + bos_token_id=1, + eos_token_id=2, + tie_word_embeddings=False, + rope_theta=10000.0, + sliding_window=4096, + attention_dropout=0.0, + **kwargs, + ): + self.vocab_size = vocab_size + self.max_position_embeddings = max_position_embeddings + self.hidden_size = hidden_size + self.intermediate_size = intermediate_size + self.num_hidden_layers = num_hidden_layers + self.num_attention_heads = num_attention_heads + self.sliding_window = sliding_window + + # for backward compatibility + if num_key_value_heads is None: + num_key_value_heads = num_attention_heads + + self.num_key_value_heads = num_key_value_heads + self.hidden_act = hidden_act + self.initializer_range = initializer_range + self.rms_norm_eps = rms_norm_eps + self.use_cache = use_cache + self.rope_theta = rope_theta + self.attention_dropout = attention_dropout + + super().__init__( + pad_token_id=pad_token_id, + bos_token_id=bos_token_id, + eos_token_id=eos_token_id, + tie_word_embeddings=tie_word_embeddings, + **kwargs, + ) \ No newline at end of file diff --git a/generation_config.json b/generation_config.json new file mode 100644 index 0000000..ada6f99 --- /dev/null +++ b/generation_config.json @@ -0,0 +1,7 @@ +{ + "_from_model_config": true, + "bos_token_id": 1, + "eos_token_id": 2, + "pad_token_id": 3, + "transformers_version": "4.38.2" +} diff --git a/model-00001-of-00002.safetensors b/model-00001-of-00002.safetensors new file mode 100644 index 0000000..20e25c1 --- /dev/null +++ b/model-00001-of-00002.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:570ae8543a5b23850965d1812830c589d1eb16ae145482723333ea46104d89f3 +size 4989311712 diff --git a/model-00002-of-00002.safetensors b/model-00002-of-00002.safetensors new file mode 100644 index 0000000..da01413 --- /dev/null +++ b/model-00002-of-00002.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:eeba5b84b9d8fb74aab67c1936a331b8417f8e748f9893f7ee063293219f40d0 +size 3517063264 diff --git a/model.safetensors.index.json b/model.safetensors.index.json new file mode 100644 index 0000000..44b5a59 --- /dev/null +++ b/model.safetensors.index.json @@ -0,0 +1,226 @@ +{ + "metadata": { + "total_size": 8506349568 + }, + "weight_map": { + "lm_head.weight": "model-00002-of-00002.safetensors", + "model.embed_tokens.weight": "model-00001-of-00002.safetensors", + "model.layers.0.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.0.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.0.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.0.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.0.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.0.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.0.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.0.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.0.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.1.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.1.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.1.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.1.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.1.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.1.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.1.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.1.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.1.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.10.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.10.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.10.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.10.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.10.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.10.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.10.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.10.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.10.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.11.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.11.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.11.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.11.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.11.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.11.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.11.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.11.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.11.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.12.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.12.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.12.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.12.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.12.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.12.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.12.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.12.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.12.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.13.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.13.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.13.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.13.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.13.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.13.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.13.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.13.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.13.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.14.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.14.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.14.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.14.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.14.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.14.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.14.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.14.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.14.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.15.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.15.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.15.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.15.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.15.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.15.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.15.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.15.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.15.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.16.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.16.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.16.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.16.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.16.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.16.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.16.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.16.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.16.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.17.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.17.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.17.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.17.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.17.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.17.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.17.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.17.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.17.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.18.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.18.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.18.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.18.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.18.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.18.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.18.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.18.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.18.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.19.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.19.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.19.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.19.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.19.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.19.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.19.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.19.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.19.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.2.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.2.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.2.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.2.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.2.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.2.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.2.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.2.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.2.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.20.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.20.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.20.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.20.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.20.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.20.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.20.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.20.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.20.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.21.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.21.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.21.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.21.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.21.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.21.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.21.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.21.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.21.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.22.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.22.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.22.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.22.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.22.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.22.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.22.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.22.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.22.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.23.input_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.23.mlp.down_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.23.mlp.gate_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.23.mlp.up_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.23.post_attention_layernorm.weight": "model-00002-of-00002.safetensors", + "model.layers.23.self_attn.k_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.23.self_attn.o_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.23.self_attn.q_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.23.self_attn.v_proj.weight": "model-00002-of-00002.safetensors", + "model.layers.3.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.3.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.3.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.3.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.3.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.3.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.3.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.3.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.3.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.4.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.4.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.4.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.4.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.4.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.4.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.4.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.4.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.4.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.5.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.5.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.5.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.5.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.5.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.5.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.5.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.5.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.5.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.6.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.6.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.6.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.6.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.6.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.6.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.6.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.6.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.6.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.7.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.7.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.7.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.7.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.7.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.7.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.7.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.7.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.7.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.8.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.8.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.8.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.8.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.8.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.8.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.8.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.8.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.8.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.9.input_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.9.mlp.down_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.9.mlp.gate_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.9.mlp.up_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.9.post_attention_layernorm.weight": "model-00001-of-00002.safetensors", + "model.layers.9.self_attn.k_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.9.self_attn.o_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.9.self_attn.q_proj.weight": "model-00001-of-00002.safetensors", + "model.layers.9.self_attn.v_proj.weight": "model-00001-of-00002.safetensors", + "model.norm.weight": "model-00002-of-00002.safetensors" + } +} diff --git a/modeling_mistral.py b/modeling_mistral.py new file mode 100644 index 0000000..53605b6 --- /dev/null +++ b/modeling_mistral.py @@ -0,0 +1,1615 @@ +# coding=utf-8 +# Copyright 2023 Mistral AI and the HuggingFace Inc. team. All rights reserved. +# +# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX +# and OPT implementations in this library. It has been modified from its +# original forms to accommodate minor architectural differences compared +# to GPT-NeoX and OPT used by the Meta AI team that trained the model. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +""" PyTorch Mistral model.""" +import inspect +import math +import warnings +from typing import List, Optional, Tuple, Union +from dataclasses import dataclass + +import torch +import torch.nn.functional as F +import torch.utils.checkpoint +from torch import nn +from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss + +from transformers.activations import ACT2FN +from transformers.cache_utils import Cache, DynamicCache +from transformers.modeling_attn_mask_utils import ( + _prepare_4d_causal_attention_mask, + _prepare_4d_causal_attention_mask_for_sdpa, + _prepare_4d_attention_mask, + _prepare_4d_attention_mask_for_sdpa, +) +from transformers.modeling_outputs import BaseModelOutputWithPast, CausalLMOutputWithPast, SequenceClassifierOutputWithPast, ModelOutput +from transformers.modeling_utils import PreTrainedModel +from transformers.utils import ( + add_start_docstrings, + add_start_docstrings_to_model_forward, + is_flash_attn_2_available, + is_flash_attn_greater_or_equal_2_10, + logging, + replace_return_docstrings, +) +from .configuration_mistral import MistralConfig + + +if is_flash_attn_2_available(): + from flash_attn import flash_attn_func, flash_attn_varlen_func + from flash_attn.bert_padding import index_first_axis, pad_input, unpad_input # noqa + + _flash_supports_window_size = "window_size" in list(inspect.signature(flash_attn_func).parameters) + print("Using flast_attn 2") + print(f"flash_attn_func supports window_size: {_flash_supports_window_size}") + + + +logger = logging.get_logger(__name__) + +_CONFIG_FOR_DOC = "MistralConfig" + + +# Copied from transformers.models.llama.modeling_llama._get_unpad_data +def _get_unpad_data(attention_mask): + seqlens_in_batch = attention_mask.sum(dim=-1, dtype=torch.int32) + indices = torch.nonzero(attention_mask.flatten(), as_tuple=False).flatten() + max_seqlen_in_batch = seqlens_in_batch.max().item() + cu_seqlens = F.pad(torch.cumsum(seqlens_in_batch, dim=0, dtype=torch.int32), (1, 0)) + return ( + indices, + cu_seqlens, + max_seqlen_in_batch, + ) + + +# Copied from transformers.models.llama.modeling_llama.LlamaRMSNorm with Llama->Mistral +class MistralRMSNorm(nn.Module): + def __init__(self, hidden_size, eps=1e-6): + """ + MistralRMSNorm is equivalent to T5LayerNorm + """ + super().__init__() + self.weight = nn.Parameter(torch.ones(hidden_size)) + self.variance_epsilon = eps + + def forward(self, hidden_states): + input_dtype = hidden_states.dtype + hidden_states = hidden_states.to(torch.float32) + variance = hidden_states.pow(2).mean(-1, keepdim=True) + hidden_states = hidden_states * torch.rsqrt(variance + self.variance_epsilon) + return self.weight * hidden_states.to(input_dtype) + + +# copied from transformers.models.llama.modeling_llama.LlamaRotaryEmbedding with Llama->Mistral +# TODO @Arthur no longer copied from LLama after static cache +class MistralRotaryEmbedding(nn.Module): + def __init__(self, dim, max_position_embeddings=2048, base=10000, device=None): + super().__init__() + + self.dim = dim + self.max_position_embeddings = max_position_embeddings + self.base = base + inv_freq = 1.0 / (self.base ** (torch.arange(0, self.dim, 2, dtype=torch.int64).float().to(device) / self.dim)) + self.register_buffer("inv_freq", inv_freq, persistent=False) + + # Build here to make `torch.jit.trace` work. + self._set_cos_sin_cache( + seq_len=max_position_embeddings, device=self.inv_freq.device, dtype=torch.get_default_dtype() + ) + + def _set_cos_sin_cache(self, seq_len, device, dtype): + self.max_seq_len_cached = seq_len + t = torch.arange(self.max_seq_len_cached, device=device, dtype=torch.int64).type_as(self.inv_freq) + + freqs = torch.outer(t, self.inv_freq) + # Different from paper, but it uses a different permutation in order to obtain the same calculation + emb = torch.cat((freqs, freqs), dim=-1) + self.register_buffer("cos_cached", emb.cos().to(dtype), persistent=False) + self.register_buffer("sin_cached", emb.sin().to(dtype), persistent=False) + + def forward(self, x, seq_len=None): + # x: [bs, num_attention_heads, seq_len, head_size] + if seq_len > self.max_seq_len_cached: + self._set_cos_sin_cache(seq_len=seq_len, device=x.device, dtype=x.dtype) + + return ( + self.cos_cached[:seq_len].to(dtype=x.dtype), + self.sin_cached[:seq_len].to(dtype=x.dtype), + ) + + +# Copied from transformers.models.llama.modeling_llama.rotate_half +def rotate_half(x): + """Rotates half the hidden dims of the input.""" + x1 = x[..., : x.shape[-1] // 2] + x2 = x[..., x.shape[-1] // 2 :] + return torch.cat((-x2, x1), dim=-1) + + +# copied from transformers.models.llama.modeling_llama.apply_rotary_pos_emb +# TODO @Arthur no longer copied from LLama after static cache +def apply_rotary_pos_emb(q, k, cos, sin, position_ids, unsqueeze_dim=1): + """Applies Rotary Position Embedding to the query and key tensors. + + Args: + q (`torch.Tensor`): The query tensor. + k (`torch.Tensor`): The key tensor. + cos (`torch.Tensor`): The cosine part of the rotary embedding. + sin (`torch.Tensor`): The sine part of the rotary embedding. + position_ids (`torch.Tensor`): + The position indices of the tokens corresponding to the query and key tensors. For example, this can be + used to pass offsetted position ids when working with a KV-cache. + unsqueeze_dim (`int`, *optional*, defaults to 1): + The 'unsqueeze_dim' argument specifies the dimension along which to unsqueeze cos[position_ids] and + sin[position_ids] so that they can be properly broadcasted to the dimensions of q and k. For example, note + that cos[position_ids] and sin[position_ids] have the shape [batch_size, seq_len, head_dim]. Then, if q and + k have the shape [batch_size, heads, seq_len, head_dim], then setting unsqueeze_dim=1 makes + cos[position_ids] and sin[position_ids] broadcastable to the shapes of q and k. Similarly, if q and k have + the shape [batch_size, seq_len, heads, head_dim], then set unsqueeze_dim=2. + Returns: + `tuple(torch.Tensor)` comprising of the query and key tensors rotated using the Rotary Position Embedding. + """ + cos = cos[position_ids].unsqueeze(unsqueeze_dim) + sin = sin[position_ids].unsqueeze(unsqueeze_dim) + q_embed = (q * cos) + (rotate_half(q) * sin) + k_embed = (k * cos) + (rotate_half(k) * sin) + return q_embed, k_embed + + +class MistralMLP(nn.Module): + def __init__(self, config): + super().__init__() + self.config = config + self.hidden_size = config.hidden_size + self.intermediate_size = config.intermediate_size + self.gate_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False) + self.up_proj = nn.Linear(self.hidden_size, self.intermediate_size, bias=False) + self.down_proj = nn.Linear(self.intermediate_size, self.hidden_size, bias=False) + self.act_fn = ACT2FN[config.hidden_act] + + def forward(self, x): + return self.down_proj(self.act_fn(self.gate_proj(x)) * self.up_proj(x)) + + +# Copied from transformers.models.llama.modeling_llama.repeat_kv +def repeat_kv(hidden_states: torch.Tensor, n_rep: int) -> torch.Tensor: + """ + This is the equivalent of torch.repeat_interleave(x, dim=1, repeats=n_rep). The hidden states go from (batch, + num_key_value_heads, seqlen, head_dim) to (batch, num_attention_heads, seqlen, head_dim) + """ + batch, num_key_value_heads, slen, head_dim = hidden_states.shape + if n_rep == 1: + return hidden_states + hidden_states = hidden_states[:, :, None, :, :].expand(batch, num_key_value_heads, n_rep, slen, head_dim) + return hidden_states.reshape(batch, num_key_value_heads * n_rep, slen, head_dim) + + +class MistralAttention(nn.Module): + """ + Multi-headed attention from 'Attention Is All You Need' paper. Modified to use sliding window attention: Longformer + and "Generating Long Sequences with Sparse Transformers". + """ + + def __init__(self, config: MistralConfig, layer_idx: Optional[int] = None): + super().__init__() + self.config = config + self.layer_idx = layer_idx + if layer_idx is None: + logger.warning_once( + f"Instantiating {self.__class__.__name__} without passing a `layer_idx` is not recommended and will " + "lead to errors during the forward call if caching is used. Please make sure to provide a `layer_idx` " + "when creating this class." + ) + + self.hidden_size = config.hidden_size + self.num_heads = config.num_attention_heads + self.head_dim = self.hidden_size // self.num_heads + self.num_key_value_heads = config.num_key_value_heads + self.num_key_value_groups = self.num_heads // self.num_key_value_heads + self.max_position_embeddings = config.max_position_embeddings + self.rope_theta = config.rope_theta + self.is_causal = config.is_causal + self.attention_dropout = config.attention_dropout + + if (self.head_dim * self.num_heads) != self.hidden_size: + raise ValueError( + f"hidden_size must be divisible by num_heads (got `hidden_size`: {self.hidden_size}" + f" and `num_heads`: {self.num_heads})." + ) + self.q_proj = nn.Linear(self.hidden_size, self.num_heads * self.head_dim, bias=False) + self.k_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False) + self.v_proj = nn.Linear(self.hidden_size, self.num_key_value_heads * self.head_dim, bias=False) + self.o_proj = nn.Linear(self.num_heads * self.head_dim, self.hidden_size, bias=False) + + self.rotary_emb = MistralRotaryEmbedding( + self.head_dim, + max_position_embeddings=self.max_position_embeddings, + base=self.rope_theta, + ) + + def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int): + return tensor.view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2).contiguous() + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_value: Optional[Cache] = None, + output_attentions: bool = False, + use_cache: bool = False, + **kwargs, + ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]: + if "padding_mask" in kwargs: + warnings.warn( + "Passing `padding_mask` is deprecated and will be removed in v4.37. Please make sure use `attention_mask` instead.`" + ) + bsz, q_len, _ = hidden_states.size() + + query_states = self.q_proj(hidden_states) + key_states = self.k_proj(hidden_states) + value_states = self.v_proj(hidden_states) + + query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2) + key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) + value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) + + kv_seq_len = key_states.shape[-2] + if past_key_value is not None: + if self.layer_idx is None: + raise ValueError( + f"The cache structure has changed since version v4.36. If you are using {self.__class__.__name__} " + "for auto-regressive decoding with k/v caching, please make sure to initialize the attention class " + "with a layer index." + ) + kv_seq_len += past_key_value.get_usable_length(kv_seq_len, self.layer_idx) + cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len) + query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids) + + if past_key_value is not None: + cache_kwargs = {"sin": sin, "cos": cos} # Specific to RoPE models + key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs) + + # repeat k/v heads if n_kv_heads < n_heads + key_states = repeat_kv(key_states, self.num_key_value_groups) + value_states = repeat_kv(value_states, self.num_key_value_groups) + + attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim) + + if attn_weights.size() != (bsz, self.num_heads, q_len, kv_seq_len): + raise ValueError( + f"Attention weights should be of size {(bsz, self.num_heads, q_len, kv_seq_len)}, but is" + f" {attn_weights.size()}" + ) + + if attention_mask is not None: + if attention_mask.size() != (bsz, 1, q_len, kv_seq_len): + raise ValueError( + f"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}" + ) + + attn_weights = attn_weights + attention_mask + + # upcast attention to fp32 + attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype) + attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training) + attn_output = torch.matmul(attn_weights, value_states) + + if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim): + raise ValueError( + f"`attn_output` should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is" + f" {attn_output.size()}" + ) + + attn_output = attn_output.transpose(1, 2).contiguous() + attn_output = attn_output.reshape(bsz, q_len, self.hidden_size) + + attn_output = self.o_proj(attn_output) + + if not output_attentions: + attn_weights = None + + return attn_output, attn_weights, past_key_value + + +class MistralFlashAttention2(MistralAttention): + """ + Mistral flash attention module. This module inherits from `MistralAttention` as the weights of the module stays + untouched. The only required change would be on the forward pass where it needs to correctly call the public API of + flash attention and deal with padding tokens in case the input contains any of them. + """ + + # Copied from transformers.models.llama.modeling_llama.LlamaFlashAttention2.__init__ + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + # TODO: Should be removed once Flash Attention for RoCm is bumped to 2.1. + # flash_attn<2.1 generates top-left aligned causal mask, while what is needed here is bottom-right alignement, that was made default for flash_attn>=2.1. This attribute is used to handle this difference. Reference: https://github.com/Dao-AILab/flash-attention/releases/tag/v2.1.0. + # Beware that with flash_attn<2.1, using q_seqlen != k_seqlen (except for the case q_seqlen == 1) produces a wrong mask (top-left). + self._flash_attn_uses_top_left_mask = not is_flash_attn_greater_or_equal_2_10() + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_value: Optional[Cache] = None, + output_attentions: bool = False, + use_cache: bool = False, + **kwargs, + ): + if "padding_mask" in kwargs: + warnings.warn( + "Passing `padding_mask` is deprecated and will be removed in v4.37. Please make sure use `attention_mask` instead.`" + ) + + # overwrite attention_mask with padding_mask + attention_mask = kwargs.pop("padding_mask") + bsz, q_len, _ = hidden_states.size() + + query_states = self.q_proj(hidden_states) + key_states = self.k_proj(hidden_states) + value_states = self.v_proj(hidden_states) + + query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2) + key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) + value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) + + kv_seq_len = key_states.shape[-2] + if past_key_value is not None: + if self.layer_idx is None: + raise ValueError( + f"The cache structure has changed since version v4.36. If you are using {self.__class__.__name__} " + "for auto-regressive decoding with k/v caching, please make sure to initialize the attention class " + "with a layer index." + ) + kv_seq_len += past_key_value.get_usable_length(kv_seq_len, self.layer_idx) + + # Because the input can be padded, the absolute sequence length depends on the max position id. + rotary_seq_len = max(kv_seq_len, position_ids[:, -1].max().item()) + 1 + cos, sin = self.rotary_emb(value_states, seq_len=rotary_seq_len) + + query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids) + + use_sliding_windows = ( + _flash_supports_window_size + and getattr(self.config, "sliding_window", None) is not None + and kv_seq_len > self.config.sliding_window + ) + + if not _flash_supports_window_size: + logger.warning_once( + "The current flash attention version does not support sliding window attention, for a more memory efficient implementation" + " make sure to upgrade flash-attn library." + ) + + if past_key_value is not None: + # Activate slicing cache only if the config has a value `sliding_windows` attribute + cache_has_contents = past_key_value.get_seq_length(self.layer_idx) > 0 + if ( + getattr(self.config, "sliding_window", None) is not None + and kv_seq_len > self.config.sliding_window + and cache_has_contents + ): + slicing_tokens = 1 - self.config.sliding_window + + past_key = past_key_value[self.layer_idx][0] + past_value = past_key_value[self.layer_idx][1] + + past_key = past_key[:, :, slicing_tokens:, :].contiguous() + past_value = past_value[:, :, slicing_tokens:, :].contiguous() + + if past_key.shape[-2] != self.config.sliding_window - 1: + raise ValueError( + f"past key must have a shape of (`batch_size, num_heads, self.config.sliding_window-1, head_dim`), got" + f" {past_key.shape}" + ) + + if attention_mask is not None: + attention_mask = attention_mask[:, slicing_tokens:] + attention_mask = torch.cat([attention_mask, torch.ones_like(attention_mask[:, -1:])], dim=-1) + + cache_kwargs = {"sin": sin, "cos": cos} # Specific to RoPE models + key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs) + + # repeat k/v heads if n_kv_heads < n_heads + key_states = repeat_kv(key_states, self.num_key_value_groups) + value_states = repeat_kv(value_states, self.num_key_value_groups) + dropout_rate = 0.0 if not self.training else self.attention_dropout + + # In PEFT, usually we cast the layer norms in float32 for training stability reasons + # therefore the input hidden states gets silently casted in float32. Hence, we need + # cast them back in float16 just to be sure everything works as expected. + input_dtype = query_states.dtype + if input_dtype == torch.float32: + if torch.is_autocast_enabled(): + target_dtype = torch.get_autocast_gpu_dtype() + # Handle the case where the model is quantized + elif hasattr(self.config, "_pre_quantization_dtype"): + target_dtype = self.config._pre_quantization_dtype + else: + target_dtype = self.q_proj.weight.dtype + + logger.warning_once( + f"The input hidden states seems to be silently casted in float32, this might be related to" + f" the fact you have upcasted embedding or layer norm layers in float32. We will cast back the input in" + f" {target_dtype}." + ) + + query_states = query_states.to(target_dtype) + key_states = key_states.to(target_dtype) + value_states = value_states.to(target_dtype) + + # Reashape to the expected shape for Flash Attention + query_states = query_states.transpose(1, 2) + key_states = key_states.transpose(1, 2) + value_states = value_states.transpose(1, 2) + + attn_output = self._flash_attention_forward( + query_states, + key_states, + value_states, + attention_mask, + q_len, + dropout=dropout_rate, + use_sliding_windows=use_sliding_windows, + ) + + attn_output = attn_output.reshape(bsz, q_len, self.hidden_size).contiguous() + attn_output = self.o_proj(attn_output) + + if not output_attentions: + attn_weights = None + + return attn_output, attn_weights, past_key_value + + def _flash_attention_forward( + self, + query_states, + key_states, + value_states, + attention_mask, + query_length, + dropout=0.0, + softmax_scale=None, + use_sliding_windows=False, + ): + """ + Calls the forward method of Flash Attention - if the input hidden states contain at least one padding token + first unpad the input, then computes the attention scores and pad the final attention scores. + + Args: + query_states (`torch.Tensor`): + Input query states to be passed to Flash Attention API + key_states (`torch.Tensor`): + Input key states to be passed to Flash Attention API + value_states (`torch.Tensor`): + Input value states to be passed to Flash Attention API + attention_mask (`torch.Tensor`): + The padding mask - corresponds to a tensor of size `(batch_size, seq_len)` where 0 stands for the + position of padding tokens and 1 for the position of non-padding tokens. + dropout (`int`, *optional*): + Attention dropout + softmax_scale (`float`, *optional*): + The scaling of QK^T before applying softmax. Default to 1 / sqrt(head_dim) + use_sliding_windows (`bool`, *optional*): + Whether to activate sliding window attention. + """ + if not self._flash_attn_uses_top_left_mask: + causal = self.is_causal + else: + # TODO: Remove the `query_length != 1` check once Flash Attention for RoCm is bumped to 2.1. For details, please see the comment in LlamaFlashAttention2 __init__. + causal = self.is_causal and query_length != 1 + + # Contains at least one padding token in the sequence + if attention_mask is not None: + batch_size = query_states.shape[0] + query_states, key_states, value_states, indices_q, cu_seq_lens, max_seq_lens = self._upad_input( + query_states, key_states, value_states, attention_mask, query_length + ) + + cu_seqlens_q, cu_seqlens_k = cu_seq_lens + max_seqlen_in_batch_q, max_seqlen_in_batch_k = max_seq_lens + + if not use_sliding_windows: + attn_output_unpad = flash_attn_varlen_func( + query_states, + key_states, + value_states, + cu_seqlens_q=cu_seqlens_q, + cu_seqlens_k=cu_seqlens_k, + max_seqlen_q=max_seqlen_in_batch_q, + max_seqlen_k=max_seqlen_in_batch_k, + dropout_p=dropout, + softmax_scale=softmax_scale, + causal=causal, + ) + else: + attn_output_unpad = flash_attn_varlen_func( + query_states, + key_states, + value_states, + cu_seqlens_q=cu_seqlens_q, + cu_seqlens_k=cu_seqlens_k, + max_seqlen_q=max_seqlen_in_batch_q, + max_seqlen_k=max_seqlen_in_batch_k, + dropout_p=dropout, + softmax_scale=softmax_scale, + causal=causal, + window_size=(self.config.sliding_window, self.config.sliding_window), + ) + + attn_output = pad_input(attn_output_unpad, indices_q, batch_size, query_length) + else: + if not use_sliding_windows: + attn_output = flash_attn_func( + query_states, + key_states, + value_states, + dropout, + softmax_scale=softmax_scale, + causal=causal, + ) + else: + attn_output = flash_attn_func( + query_states, + key_states, + value_states, + dropout, + softmax_scale=softmax_scale, + causal=causal, + window_size=(self.config.sliding_window, self.config.sliding_window), + ) + + return attn_output + + def _upad_input(self, query_layer, key_layer, value_layer, attention_mask, query_length): + batch_size, kv_seq_len, num_heads, head_dim = key_layer.shape + + # On the first iteration we need to properly re-create the padding mask + # by slicing it on the proper place + if kv_seq_len != attention_mask.shape[-1]: + attention_mask_num_tokens = attention_mask.shape[-1] + attention_mask = attention_mask[:, attention_mask_num_tokens - kv_seq_len :] + + indices_k, cu_seqlens_k, max_seqlen_in_batch_k = _get_unpad_data(attention_mask) + + key_layer = index_first_axis(key_layer.reshape(batch_size * kv_seq_len, num_heads, head_dim), indices_k) + value_layer = index_first_axis(value_layer.reshape(batch_size * kv_seq_len, num_heads, head_dim), indices_k) + + if query_length == kv_seq_len: + query_layer = index_first_axis( + query_layer.reshape(batch_size * kv_seq_len, num_heads, head_dim), indices_k + ) + cu_seqlens_q = cu_seqlens_k + max_seqlen_in_batch_q = max_seqlen_in_batch_k + indices_q = indices_k + elif query_length == 1: + max_seqlen_in_batch_q = 1 + cu_seqlens_q = torch.arange( + batch_size + 1, dtype=torch.int32, device=query_layer.device + ) # There is a memcpy here, that is very bad. + indices_q = cu_seqlens_q[:-1] + query_layer = query_layer.squeeze(1) + else: + # The -q_len: slice assumes left padding. + attention_mask = attention_mask[:, -query_length:] + query_layer, indices_q, cu_seqlens_q, max_seqlen_in_batch_q = unpad_input(query_layer, attention_mask) + + return ( + query_layer, + key_layer, + value_layer, + indices_q, + (cu_seqlens_q, cu_seqlens_k), + (max_seqlen_in_batch_q, max_seqlen_in_batch_k), + ) + + +# copied from transformers.models.llama.modeling_llama.LlamaSdpaAttention with Llama->Mistral +# TODO @Arthur no longer copied from LLama after static cache +class MistralSdpaAttention(MistralAttention): + """ + Mistral attention module using torch.nn.functional.scaled_dot_product_attention. This module inherits from + `MistralAttention` as the weights of the module stays untouched. The only changes are on the forward pass to adapt to + SDPA API. + """ + + # Adapted from MistralAttention.forward + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_value: Optional[Cache] = None, + output_attentions: bool = False, + use_cache: bool = False, + ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]: + if output_attentions: + # TODO: Improve this warning with e.g. `model.config.attn_implementation = "manual"` once this is implemented. + logger.warning_once( + "MistralModel is using MistralSdpaAttention, but `torch.nn.functional.scaled_dot_product_attention` does not support `output_attentions=True`. Falling back to the manual attention implementation, " + 'but specifying the manual implementation will be required from Transformers version v5.0.0 onwards. This warning can be removed using the argument `attn_implementation="eager"` when loading the model.' + ) + return super().forward( + hidden_states=hidden_states, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_value=past_key_value, + output_attentions=output_attentions, + use_cache=use_cache, + ) + + bsz, q_len, _ = hidden_states.size() + + query_states = self.q_proj(hidden_states) + key_states = self.k_proj(hidden_states) + value_states = self.v_proj(hidden_states) + + query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2) + key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) + value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) + + kv_seq_len = key_states.shape[-2] + if past_key_value is not None: + kv_seq_len += past_key_value.get_usable_length(kv_seq_len, self.layer_idx) + cos, sin = self.rotary_emb(value_states, seq_len=kv_seq_len) + + query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin, position_ids) + + if past_key_value is not None: + cache_kwargs = {"sin": sin, "cos": cos} # Specific to RoPE models + key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs) + + key_states = repeat_kv(key_states, self.num_key_value_groups) + value_states = repeat_kv(value_states, self.num_key_value_groups) + + if attention_mask is not None: + if attention_mask.size() != (bsz, 1, q_len, kv_seq_len): + raise ValueError( + f"Attention mask should be of size {(bsz, 1, q_len, kv_seq_len)}, but is {attention_mask.size()}" + ) + + # SDPA with memory-efficient backend is currently (torch==2.1.2) bugged with non-contiguous inputs with custom attn_mask, + # Reference: https://github.com/pytorch/pytorch/issues/112577. + if query_states.device.type == "cuda" and attention_mask is not None: + query_states = query_states.contiguous() + key_states = key_states.contiguous() + value_states = value_states.contiguous() + + attn_output = torch.nn.functional.scaled_dot_product_attention( + query_states, + key_states, + value_states, + attn_mask=attention_mask, + dropout_p=self.attention_dropout if self.training else 0.0, + # The q_len > 1 is necessary to match with AttentionMaskConverter.to_causal_4d that does not create a causal mask in case q_len == 1. + is_causal=self.is_causal and attention_mask is None and q_len > 1, + ) + + attn_output = attn_output.transpose(1, 2).contiguous() + attn_output = attn_output.view(bsz, q_len, self.hidden_size) + + attn_output = self.o_proj(attn_output) + + return attn_output, None, past_key_value + + +MISTRAL_ATTENTION_CLASSES = { + "eager": MistralAttention, + "flash_attention_2": MistralFlashAttention2, + "sdpa": MistralSdpaAttention, +} + + +class MistralDecoderLayer(nn.Module): + def __init__(self, config: MistralConfig, layer_idx: int): + super().__init__() + self.hidden_size = config.hidden_size + + self.self_attn = MISTRAL_ATTENTION_CLASSES[config._attn_implementation](config, layer_idx) + + self.mlp = MistralMLP(config) + self.input_layernorm = MistralRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + self.post_attention_layernorm = MistralRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + + def forward( + self, + hidden_states: torch.Tensor, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_value: Optional[Tuple[torch.Tensor]] = None, + output_attentions: Optional[bool] = False, + use_cache: Optional[bool] = False, + **kwargs, + ) -> Tuple[torch.FloatTensor, Optional[Tuple[torch.FloatTensor, torch.FloatTensor]]]: + if "padding_mask" in kwargs: + warnings.warn( + "Passing `padding_mask` is deprecated and will be removed in v4.37. Please make sure use `attention_mask` instead.`" + ) + """ + Args: + hidden_states (`torch.FloatTensor`): input to the layer of shape `(batch, seq_len, embed_dim)` + attention_mask (`torch.FloatTensor`, *optional*): attention mask of size + `(batch, sequence_length)` where padding elements are indicated by 0. + output_attentions (`bool`, *optional*): + Whether or not to return the attentions tensors of all attention layers. See `attentions` under + returned tensors for more detail. + use_cache (`bool`, *optional*): + If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding + (see `past_key_values`). + past_key_value (`Tuple(torch.FloatTensor)`, *optional*): cached past key and value projection states + """ + + residual = hidden_states + + hidden_states = self.input_layernorm(hidden_states) + + # Self Attention + hidden_states, self_attn_weights, present_key_value = self.self_attn( + hidden_states=hidden_states, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_value=past_key_value, + output_attentions=output_attentions, + use_cache=use_cache, + ) + hidden_states = residual + hidden_states + + # Fully Connected + residual = hidden_states + hidden_states = self.post_attention_layernorm(hidden_states) + hidden_states = self.mlp(hidden_states) + hidden_states = residual + hidden_states + + outputs = (hidden_states,) + + if output_attentions: + outputs += (self_attn_weights,) + + if use_cache: + outputs += (present_key_value,) + + return outputs + + +MISTRAL_START_DOCSTRING = r""" + This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the + library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads + etc.) + + This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. + Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage + and behavior. + + Parameters: + config ([`MistralConfig`]): + Model configuration class with all the parameters of the model. Initializing with a config file does not + load the weights associated with the model, only the configuration. Check out the + [`~PreTrainedModel.from_pretrained`] method to load the model weights. +""" + + +@add_start_docstrings( + "The bare Mistral Model outputting raw hidden-states without any specific head on top.", + MISTRAL_START_DOCSTRING, +) +class MistralPreTrainedModel(PreTrainedModel): + config_class = MistralConfig + base_model_prefix = "model" + supports_gradient_checkpointing = True + _no_split_modules = ["MistralDecoderLayer"] + _skip_keys_device_placement = "past_key_values" + _supports_flash_attn_2 = True + _supports_sdpa = True + _supports_cache_class = True + + def _init_weights(self, module): + std = self.config.initializer_range + if isinstance(module, nn.Linear): + module.weight.data.normal_(mean=0.0, std=std) + if module.bias is not None: + module.bias.data.zero_() + elif isinstance(module, nn.Embedding): + module.weight.data.normal_(mean=0.0, std=std) + if module.padding_idx is not None: + module.weight.data[module.padding_idx].zero_() + + +MISTRAL_INPUTS_DOCSTRING = r""" + Args: + input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`): + Indices of input sequence tokens in the vocabulary. Padding will be ignored by default should you provide + it. + + Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and + [`PreTrainedTokenizer.__call__`] for details. + + [What are input IDs?](../glossary#input-ids) + attention_mask (`torch.Tensor` of shape `(batch_size, sequence_length)`, *optional*): + Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`: + + - 1 for tokens that are **not masked**, + - 0 for tokens that are **masked**. + + [What are attention masks?](../glossary#attention-mask) + + Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and + [`PreTrainedTokenizer.__call__`] for details. + + If `past_key_values` is used, optionally only the last `decoder_input_ids` have to be input (see + `past_key_values`). + + If you want to change padding behavior, you should read [`modeling_opt._prepare_decoder_attention_mask`] + and modify to your needs. See diagram 1 in [the paper](https://arxiv.org/abs/1910.13461) for more + information on the default strategy. + + - 1 indicates the head is **not masked**, + - 0 indicates the head is **masked**. + position_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): + Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0, + config.n_positions - 1]`. + + [What are position IDs?](../glossary#position-ids) + past_key_values (`Cache` or `tuple(tuple(torch.FloatTensor))`, *optional*): + Pre-computed hidden-states (key and values in the self-attention blocks and in the cross-attention + blocks) that can be used to speed up sequential decoding. This typically consists in the `past_key_values` + returned by the model at a previous stage of decoding, when `use_cache=True` or `config.use_cache=True`. + + Two formats are allowed: + - a [`~cache_utils.Cache`] instance; + - Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of + shape `(batch_size, num_heads, sequence_length, embed_size_per_head)`). This is also known as the legacy + cache format. + + The model will output the same cache format that is fed as input. If no `past_key_values` are passed, the + legacy cache format will be returned. + + If `past_key_values` are used, the user can optionally input only the last `input_ids` (those that don't + have their past key value states given to this model) of shape `(batch_size, 1)` instead of all `input_ids` + of shape `(batch_size, sequence_length)`. + inputs_embeds (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*): + Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This + is useful if you want more control over how to convert `input_ids` indices into associated vectors than the + model's internal embedding lookup matrix. + use_cache (`bool`, *optional*): + If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see + `past_key_values`). + output_attentions (`bool`, *optional*): + Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned + tensors for more detail. + output_hidden_states (`bool`, *optional*): + Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for + more detail. + return_dict (`bool`, *optional*): + Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple. +""" + + +@add_start_docstrings( + "The bare Mistral Model outputting raw hidden-states without any specific head on top.", + MISTRAL_START_DOCSTRING, +) +class MistralModel(MistralPreTrainedModel): + """ + Transformer decoder consisting of *config.num_hidden_layers* layers. Each layer is a [`MistralDecoderLayer`] + + Args: + config: MistralConfig + """ + + def __init__(self, config: MistralConfig): + super().__init__(config) + self.padding_idx = config.pad_token_id + self.vocab_size = config.vocab_size + self.is_causal = config.is_causal + + self.embed_tokens = nn.Embedding(config.vocab_size, config.hidden_size, self.padding_idx) + self.layers = nn.ModuleList( + [MistralDecoderLayer(config, layer_idx) for layer_idx in range(config.num_hidden_layers)] + ) + self._attn_implementation = config._attn_implementation + self.norm = MistralRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + + self.gradient_checkpointing = False + # Initialize weights and apply final processing + self.post_init() + + def get_input_embeddings(self): + return self.embed_tokens + + def set_input_embeddings(self, value): + self.embed_tokens = value + + @add_start_docstrings_to_model_forward(MISTRAL_INPUTS_DOCSTRING) + def forward( + self, + input_ids: torch.LongTensor = None, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_values: Optional[List[torch.FloatTensor]] = None, + inputs_embeds: Optional[torch.FloatTensor] = None, + use_cache: Optional[bool] = None, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ) -> Union[Tuple, BaseModelOutputWithPast]: + output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions + output_hidden_states = ( + output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states + ) + use_cache = use_cache if use_cache is not None else self.config.use_cache + + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + # retrieve input_ids and inputs_embeds + if input_ids is not None and inputs_embeds is not None: + raise ValueError("You cannot specify both decoder_input_ids and decoder_inputs_embeds at the same time") + elif input_ids is not None: + batch_size, seq_length = input_ids.shape + elif inputs_embeds is not None: + batch_size, seq_length, _ = inputs_embeds.shape + else: + raise ValueError("You have to specify either decoder_input_ids or decoder_inputs_embeds") + + if self.gradient_checkpointing and self.training: + if use_cache: + logger.warning_once( + "`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..." + ) + use_cache = False + + past_key_values_length = 0 + + if use_cache: + use_legacy_cache = not isinstance(past_key_values, Cache) + if use_legacy_cache: + past_key_values = DynamicCache.from_legacy_cache(past_key_values) + past_key_values_length = past_key_values.get_usable_length(seq_length) + + if position_ids is None: + device = input_ids.device if input_ids is not None else inputs_embeds.device + position_ids = torch.arange( + past_key_values_length, seq_length + past_key_values_length, dtype=torch.long, device=device + ) + position_ids = position_ids.unsqueeze(0).view(-1, seq_length) + else: + position_ids = position_ids.view(-1, seq_length).long() + + if inputs_embeds is None: + inputs_embeds = self.embed_tokens(input_ids) + + if attention_mask is not None and self._attn_implementation == "flash_attention_2" and use_cache: + is_padding_right = attention_mask[:, -1].sum().item() != batch_size + if is_padding_right: + raise ValueError( + "You are attempting to perform batched generation with padding_side='right'" + " this may lead to unexpected behaviour for Flash Attention version of Mistral. Make sure to " + " call `tokenizer.padding_side = 'left'` before tokenizing the input. " + ) + + + if self._attn_implementation == "flash_attention_2": + # 2d mask is passed through the layers + attention_mask = attention_mask if (attention_mask is not None and 0 in attention_mask) else None + elif self._attn_implementation == "sdpa" and not output_attentions: + # output_attentions=True can not be supported when using SDPA, and we fall back on + # the manual implementation that requires a 4D causal mask in all cases. + if self.is_causal: + attention_mask = _prepare_4d_causal_attention_mask_for_sdpa( + attention_mask, + (batch_size, seq_length), + inputs_embeds, + past_key_values_length, + ) + else: + attention_mask = _prepare_4d_attention_mask_for_sdpa( + attention_mask, + dtype=inputs_embeds.dtype, + ) + else: + # 4d mask is passed through the layers + if self.is_causal: + attention_mask = _prepare_4d_causal_attention_mask( + attention_mask, + (batch_size, seq_length), + inputs_embeds, + past_key_values_length, + sliding_window=self.config.sliding_window, + ) + else: + attention_mask = _prepare_4d_attention_mask( + attention_mask, + dtype=inputs_embeds.dtype, + ) + + hidden_states = inputs_embeds + + # decoder layers + all_hidden_states = () if output_hidden_states else None + all_self_attns = () if output_attentions else None + next_decoder_cache = None + + for decoder_layer in self.layers: + if output_hidden_states: + all_hidden_states += (hidden_states,) + + if self.gradient_checkpointing and self.training: + layer_outputs = self._gradient_checkpointing_func( + decoder_layer.__call__, + hidden_states, + attention_mask, + position_ids, + past_key_values, + output_attentions, + use_cache, + ) + else: + layer_outputs = decoder_layer( + hidden_states, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_value=past_key_values, + output_attentions=output_attentions, + use_cache=use_cache, + ) + + hidden_states = layer_outputs[0] + + if use_cache: + next_decoder_cache = layer_outputs[2 if output_attentions else 1] + + if output_attentions: + all_self_attns += (layer_outputs[1],) + + hidden_states = self.norm(hidden_states) + + # add hidden states from the last decoder layer + if output_hidden_states: + all_hidden_states += (hidden_states,) + + next_cache = None + if use_cache: + next_cache = next_decoder_cache.to_legacy_cache() if use_legacy_cache else next_decoder_cache + + if not return_dict: + return tuple(v for v in [hidden_states, next_cache, all_hidden_states, all_self_attns] if v is not None) + return BaseModelOutputWithPast( + last_hidden_state=hidden_states, + past_key_values=next_cache, + hidden_states=all_hidden_states, + attentions=all_self_attns, + ) + + +class MistralForCausalLM(MistralPreTrainedModel): + _tied_weights_keys = ["lm_head.weight"] + + def __init__(self, config): + super().__init__(config) + self.model = MistralModel(config) + self.vocab_size = config.vocab_size + self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False) + + # Initialize weights and apply final processing + self.post_init() + + def get_input_embeddings(self): + return self.model.embed_tokens + + def set_input_embeddings(self, value): + self.model.embed_tokens = value + + def get_output_embeddings(self): + return self.lm_head + + def set_output_embeddings(self, new_embeddings): + self.lm_head = new_embeddings + + def set_decoder(self, decoder): + self.model = decoder + + def get_decoder(self): + return self.model + + @add_start_docstrings_to_model_forward(MISTRAL_INPUTS_DOCSTRING) + @replace_return_docstrings(output_type=CausalLMOutputWithPast, config_class=_CONFIG_FOR_DOC) + def forward( + self, + input_ids: torch.LongTensor = None, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_values: Optional[List[torch.FloatTensor]] = None, + inputs_embeds: Optional[torch.FloatTensor] = None, + labels: Optional[torch.LongTensor] = None, + use_cache: Optional[bool] = None, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ) -> Union[Tuple, CausalLMOutputWithPast]: + r""" + Args: + labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): + Labels for computing the masked language modeling loss. Indices should either be in `[0, ..., + config.vocab_size]` or -100 (see `input_ids` docstring). Tokens with indices set to `-100` are ignored + (masked), the loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`. + + Returns: + + Example: + + ```python + >>> from transformers import AutoTokenizer, MistralForCausalLM + + >>> model = MistralForCausalLM.from_pretrained("mistralai/Mistral-7B-v0.1") + >>> tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-v0.1") + + >>> prompt = "Hey, are you conscious? Can you talk to me?" + >>> inputs = tokenizer(prompt, return_tensors="pt") + + >>> # Generate + >>> generate_ids = model.generate(inputs.input_ids, max_length=30) + >>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0] + "Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you." + ```""" + + output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions + output_hidden_states = ( + output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states + ) + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn) + outputs = self.model( + input_ids=input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_values=past_key_values, + inputs_embeds=inputs_embeds, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + hidden_states = outputs[0] + logits = self.lm_head(hidden_states) + logits = logits.float() + + loss = None + if labels is not None: + # Shift so that tokens < n predict n + shift_logits = logits[..., :-1, :].contiguous() + shift_labels = labels[..., 1:].contiguous() + # Flatten the tokens + loss_fct = CrossEntropyLoss() + shift_logits = shift_logits.view(-1, self.config.vocab_size) + shift_labels = shift_labels.view(-1) + # Enable model parallelism + shift_labels = shift_labels.to(shift_logits.device) + loss = loss_fct(shift_logits, shift_labels) + + if not return_dict: + output = (logits,) + outputs[1:] + return (loss,) + output if loss is not None else output + + return CausalLMOutputWithPast( + loss=loss, + logits=logits, + past_key_values=outputs.past_key_values, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) + + def prepare_inputs_for_generation( + self, input_ids, past_key_values=None, attention_mask=None, inputs_embeds=None, **kwargs + ): + # Omit tokens covered by past_key_values + if past_key_values is not None: + if isinstance(past_key_values, Cache): + cache_length = past_key_values.get_seq_length() + past_length = past_key_values.seen_tokens + max_cache_length = past_key_values.get_max_length() + else: + cache_length = past_length = past_key_values[0][0].shape[2] + max_cache_length = None + + # Keep only the unprocessed tokens: + # 1 - If the length of the attention_mask exceeds the length of input_ids, then we are in a setting where + # some of the inputs are exclusively passed as part of the cache (e.g. when passing input_embeds as + # input) + if attention_mask is not None and attention_mask.shape[1] > input_ids.shape[1]: + input_ids = input_ids[:, -(attention_mask.shape[1] - past_length) :] + # 2 - If the past_length is smaller than input_ids', then input_ids holds all input tokens. We can discard + # input_ids based on the past_length. + elif past_length < input_ids.shape[1]: + input_ids = input_ids[:, past_length:] + # 3 - Otherwise (past_length >= input_ids.shape[1]), let's assume input_ids only has unprocessed tokens. + + # If we are about to go beyond the maximum cache length, we need to crop the input attention mask. + if ( + max_cache_length is not None + and attention_mask is not None + and cache_length + input_ids.shape[1] > max_cache_length + ): + attention_mask = attention_mask[:, -max_cache_length:] + + position_ids = kwargs.get("position_ids", None) + if attention_mask is not None and position_ids is None: + # create position_ids on the fly for batch generation + position_ids = attention_mask.long().cumsum(-1) - 1 + position_ids.masked_fill_(attention_mask == 0, 1) + if past_key_values: + position_ids = position_ids[:, -input_ids.shape[1] :] + + # if `inputs_embeds` are passed, we only want to use them in the 1st generation step + if inputs_embeds is not None and past_key_values is None: + model_inputs = {"inputs_embeds": inputs_embeds} + else: + model_inputs = {"input_ids": input_ids} + + model_inputs.update( + { + "position_ids": position_ids, + "past_key_values": past_key_values, + "use_cache": kwargs.get("use_cache"), + "attention_mask": attention_mask, + } + ) + return model_inputs + + @staticmethod + def _reorder_cache(past_key_values, beam_idx): + reordered_past = () + for layer_past in past_key_values: + reordered_past += ( + tuple(past_state.index_select(0, beam_idx.to(past_state.device)) for past_state in layer_past), + ) + return reordered_past + + + + +@dataclass +class MoEMaskedLMOutput(ModelOutput): + """ + Base class for causal language model (or autoregressive) outputs as well as Mixture of Expert's router hidden + states terms, to train a MoE model. + + Args: + loss (`torch.FloatTensor` of shape `(1,)`, *optional*, returned when `labels` is provided): + Language modeling loss (for next-token prediction). + logits (`torch.FloatTensor` of shape `(batch_size, sequence_length, config.vocab_size)`): + Prediction scores of the language modeling head (scores for each vocabulary token before SoftMax). + past_key_values (`tuple(tuple(torch.FloatTensor))`, *optional*, returned when `use_cache=True` is passed or when `config.use_cache=True`): + Tuple of `tuple(torch.FloatTensor)` of length `config.n_layers`, with each tuple having 2 tensors of shape + `(batch_size, num_heads, sequence_length, embed_size_per_head)`) + + Contains pre-computed hidden-states (key and values in the self-attention blocks) that can be used (see + `past_key_values` input) to speed up sequential decoding. + hidden_states (`tuple(torch.FloatTensor)`, *optional*, returned when `output_hidden_states=True` is passed or when `config.output_hidden_states=True`): + Tuple of `torch.FloatTensor` (one for the output of the embeddings, if the model has an embedding layer, + + one for the output of each layer) of shape `(batch_size, sequence_length, hidden_size)`. + + Hidden-states of the model at the output of each layer plus the optional initial embedding outputs. + attentions (`tuple(torch.FloatTensor)`, *optional*, returned when `output_attentions=True` is passed or when `config.output_attentions=True`): + Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, num_heads, sequence_length, + sequence_length)`. + + Attentions weights after the attention softmax, used to compute the weighted average in the self-attention + heads. + z_loss (`torch.FloatTensor`, *optional*, returned when `labels` is provided): + z_loss for the sparse modules. + aux_loss (`torch.FloatTensor`, *optional*, returned when `labels` is provided): + aux_loss for the sparse modules. + router_logits (`tuple(torch.FloatTensor)`, *optional*, returned when `output_router_logits=True` is passed or when `config.add_router_probs=True`): + Tuple of `torch.FloatTensor` (one for each layer) of shape `(batch_size, sequence_length, num_experts)`. + + Router logits of the encoder model, useful to compute the auxiliary loss and the z_loss for the sparse + modules. + """ + + loss: Optional[torch.FloatTensor] = None + logits: torch.FloatTensor = None + hidden_states: Optional[Tuple[torch.FloatTensor, ...]] = None + attentions: Optional[Tuple[torch.FloatTensor, ...]] = None + z_loss: torch.FloatTensor = None + aux_loss: torch.FloatTensor = None + router_logits: Optional[Tuple[torch.FloatTensor]] = None + + + +class MistralPredictionHeadTransform(nn.Module): + def __init__(self, config): + super().__init__() + self.dense = nn.Linear(config.hidden_size, config.hidden_size) + if isinstance(config.hidden_act, str): + self.transform_act_fn = ACT2FN[config.hidden_act] + else: + self.transform_act_fn = config.hidden_act + self.norm = MistralRMSNorm(config.hidden_size, eps=config.rms_norm_eps) + + def forward(self, hidden_states: torch.Tensor) -> torch.Tensor: + hidden_states = self.dense(hidden_states) + hidden_states = self.transform_act_fn(hidden_states) + hidden_states = self.norm(hidden_states) + return hidden_states + + +class MistralLMPredictionHead(nn.Module): + def __init__(self, config): + super().__init__() + self.transform = MistralPredictionHeadTransform(config) + + # The output weights are the same as the input embeddings, but there is + # an output-only bias for each token. + self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False) + + self.bias = nn.Parameter(torch.zeros(config.vocab_size)) + + # Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings` + self.decoder.bias = self.bias + + def _tie_weights(self): + self.decoder.bias = self.bias + + def forward(self, hidden_states): + hidden_states = self.transform(hidden_states) + hidden_states = self.decoder(hidden_states) + return hidden_states + + +class MistralOnlyMLMHead(nn.Module): + def __init__(self, config): + super().__init__() + self.predictions = MistralLMPredictionHead(config) + + def forward(self, sequence_output: torch.Tensor) -> torch.Tensor: + prediction_scores = self.predictions(sequence_output) + return prediction_scores + + + +class MistralForMaskedLM(MistralPreTrainedModel): + _tied_weights_keys = ["predictions.decoder.bias", "cls.predictions.decoder.weight"] + + def __init__(self, config): + super().__init__(config) + + if config.is_decoder: + logger.warning( + "If you want to use `MistralForMaskedLM` make sure `config.is_decoder=False` for " + "bi-directional self-attention." + ) + + self.model = MistralModel(config) + self.cls = MistralOnlyMLMHead(config) + + # Initialize weights and apply final processing + self.post_init() + + def get_output_embeddings(self): + return self.cls.predictions.decoder + + def set_output_embeddings(self, new_embeddings): + self.cls.predictions.decoder = new_embeddings + self.cls.predictions.bias = new_embeddings.bias + + def forward( + self, + input_ids: Optional[torch.Tensor] = None, + attention_mask: Optional[torch.Tensor] = None, + token_type_ids: Optional[torch.Tensor] = None, + position_ids: Optional[torch.Tensor] = None, + inputs_embeds: Optional[torch.Tensor] = None, + labels: Optional[torch.Tensor] = None, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ) -> Union[Tuple[torch.Tensor], MoEMaskedLMOutput]: + r""" + labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*): + Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ..., + config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the + loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]` + """ + + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + outputs = self.model( + input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + inputs_embeds=inputs_embeds, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + + + sequence_output = outputs[0] + logits = self.cls(sequence_output) + + loss = None + if labels is not None: + loss_fct = CrossEntropyLoss() # -100 index = padding token + loss = loss_fct(logits.view(-1, self.config.vocab_size), labels.view(-1)) + + + if not return_dict: + output = (logits,) + outputs[2:] + return ((loss,) + output) if loss is not None else output + + return MoEMaskedLMOutput( + loss=loss, + logits=logits, + hidden_states=outputs.hidden_states, + attentions=outputs.attentions, + ) + + + + +@add_start_docstrings( + """ + The Mistral Model transformer with a sequence classification head on top (linear layer). + + [`MistralForSequenceClassification`] uses the last token in order to do the classification, as other causal models + (e.g. GPT-2) do. + + Since it does classification on the last token, it requires to know the position of the last token. If a + `pad_token_id` is defined in the configuration, it finds the last token that is not a padding token in each row. If + no `pad_token_id` is defined, it simply takes the last value in each row of the batch. Since it cannot guess the + padding tokens when `inputs_embeds` are passed instead of `input_ids`, it does the same (take the last value in + each row of the batch). + """, + MISTRAL_START_DOCSTRING, +) +# Copied from transformers.models.llama.modeling_llama.LlamaForSequenceClassification with Llama->Mistral, LLAMA->MISTRAL +class MistralForSequenceClassification(MistralPreTrainedModel): + def __init__(self, config): + super().__init__(config) + self.num_labels = config.num_labels + self.model = MistralModel(config) + self.score = nn.Linear(config.hidden_size, self.num_labels, bias=False) + self.dropout = nn.Dropout(config.classifier_dropout) + self.is_causal = config.is_causal + + + # Initialize weights and apply final processing + self.post_init() + + def get_input_embeddings(self): + return self.model.embed_tokens + + def set_input_embeddings(self, value): + self.model.embed_tokens = value + + @add_start_docstrings_to_model_forward(MISTRAL_INPUTS_DOCSTRING) + def forward( + self, + input_ids: torch.LongTensor = None, + attention_mask: Optional[torch.Tensor] = None, + position_ids: Optional[torch.LongTensor] = None, + past_key_values: Optional[List[torch.FloatTensor]] = None, + inputs_embeds: Optional[torch.FloatTensor] = None, + labels: Optional[torch.LongTensor] = None, + use_cache: Optional[bool] = None, + output_attentions: Optional[bool] = None, + output_hidden_states: Optional[bool] = None, + return_dict: Optional[bool] = None, + ) -> Union[Tuple, SequenceClassifierOutputWithPast]: + r""" + labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*): + Labels for computing the sequence classification/regression loss. Indices should be in `[0, ..., + config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If + `config.num_labels > 1` a classification loss is computed (Cross-Entropy). + """ + return_dict = return_dict if return_dict is not None else self.config.use_return_dict + + transformer_outputs = self.model( + input_ids, + attention_mask=attention_mask, + position_ids=position_ids, + past_key_values=past_key_values, + inputs_embeds=inputs_embeds, + use_cache=use_cache, + output_attentions=output_attentions, + output_hidden_states=output_hidden_states, + return_dict=return_dict, + ) + hidden_states = transformer_outputs[0] + hidden_states = self.dropout(hidden_states) + logits = self.score(hidden_states) + + if input_ids is not None: + batch_size = input_ids.shape[0] + else: + batch_size = inputs_embeds.shape[0] + + if self.is_causal: + if self.config.pad_token_id is None and batch_size != 1: + raise ValueError("Cannot handle batch sizes > 1 if no padding token is defined.") + if self.config.pad_token_id is None: + sequence_lengths = -1 + else: + if input_ids is not None: + # if no pad token found, use modulo instead of reverse indexing for ONNX compatibility + sequence_lengths = torch.eq(input_ids, self.config.pad_token_id).int().argmax(-1) - 1 + sequence_lengths = sequence_lengths % input_ids.shape[-1] + sequence_lengths = sequence_lengths.to(logits.device) + else: + sequence_lengths = -1 + + pooled_logits = logits[torch.arange(batch_size, device=logits.device), sequence_lengths] + else: + pooled_logits = logits[:, 0] + + loss = None + if labels is not None: + labels = labels.to(logits.device) + if self.config.problem_type is None: + if self.num_labels == 1: + self.config.problem_type = "regression" + elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int): + self.config.problem_type = "single_label_classification" + else: + self.config.problem_type = "multi_label_classification" + + if self.config.problem_type == "regression": + loss_fct = MSELoss() + if self.num_labels == 1: + loss = loss_fct(pooled_logits.squeeze(), labels.squeeze()) + else: + loss = loss_fct(pooled_logits, labels) + elif self.config.problem_type == "single_label_classification": + loss_fct = CrossEntropyLoss() + loss = loss_fct(pooled_logits.view(-1, self.num_labels), labels.view(-1)) + elif self.config.problem_type == "multi_label_classification": + loss_fct = BCEWithLogitsLoss() + loss = loss_fct(pooled_logits, labels) + if not return_dict: + output = (pooled_logits,) + transformer_outputs[1:] + return ((loss,) + output) if loss is not None else output + + return SequenceClassifierOutputWithPast( + loss=loss, + logits=pooled_logits, + past_key_values=transformer_outputs.past_key_values, + hidden_states=transformer_outputs.hidden_states, + attentions=transformer_outputs.attentions, + ) + +# import torch +# from safetensors import safe_open +# from safetensors.torch import save_file + +# tensors = {} +# with safe_open("/root/MOE_DNA/trained_model/mistral_mlm_alldata_len5k_ep3/model.safetensors", framework="pt", device="cpu") as f: +# # print(f.metadata()) + +# for key in f.keys(): +# tensors[key] = f.get_tensor(key) + +# new_model = {} +# for key in tensors.keys(): +# k = key.replace("Mistral", "model") +# new_model[k] = tensors[key] + diff --git a/special_tokens_map.json b/special_tokens_map.json new file mode 100644 index 0000000..9bbecc1 --- /dev/null +++ b/special_tokens_map.json @@ -0,0 +1,37 @@ +{ + "cls_token": { + "content": "[CLS]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false + }, + "mask_token": { + "content": "[MASK]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false + }, + "pad_token": { + "content": "[PAD]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false + }, + "sep_token": { + "content": "[SEP]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false + }, + "unk_token": { + "content": "[UNK]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false + } +} diff --git a/tokenizer.json b/tokenizer.json new file mode 100644 index 0000000..5aedf0f --- /dev/null +++ b/tokenizer.json @@ -0,0 +1,8327 @@ +{ + "version": "1.0", + "truncation": null, + "padding": null, + "added_tokens": [ + { + "id": 0, + "content": "[UNK]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 1, + "content": "[CLS]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 2, + "content": "[SEP]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 3, + "content": "[PAD]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + }, + { + "id": 4, + "content": "[MASK]", + "single_word": false, + "lstrip": false, + "rstrip": false, + "normalized": false, + "special": true + } + ], + "normalizer": null, + "pre_tokenizer": { + "type": "Whitespace" + }, + "post_processor": { + "type": "TemplateProcessing", + "single": [ + { + "SpecialToken": { + "id": "[CLS]", + "type_id": 0 + } + }, + { + "Sequence": { + "id": "A", + "type_id": 0 + } + }, + { + "SpecialToken": { + "id": "[SEP]", + "type_id": 0 + } + } + ], + "pair": [ + { + "SpecialToken": { + "id": "[CLS]", + "type_id": 0 + } + }, + { + "Sequence": { + "id": "A", + "type_id": 0 + } + }, + { + "SpecialToken": { + "id": "[SEP]", + "type_id": 0 + } + }, + { + "Sequence": { + "id": "B", + "type_id": 1 + } + }, + { + "SpecialToken": { + "id": "[SEP]", + "type_id": 1 + } + } + ], + "special_tokens": { + "[CLS]": { + "id": "[CLS]", + "ids": [ + 1 + ], + "tokens": [ + "[CLS]" + ] + }, + "[SEP]": { + "id": "[SEP]", + "ids": [ + 2 + ], + "tokens": [ + "[SEP]" + ] + } + } + }, + "decoder": null, + "model": { + "type": "BPE", + "dropout": null, + "unk_token": "[UNK]", + "continuing_subword_prefix": null, + "end_of_word_suffix": null, + "fuse_unk": false, + "byte_fallback": false, + "vocab": { + "[UNK]": 0, + "[CLS]": 1, + "[SEP]": 2, + "[PAD]": 3, + "[MASK]": 4, + "A": 5, + "C": 6, + "G": 7, + "N": 8, + "T": 9, + "CG": 10, + "CA": 11, + "TG": 12, + "AA": 13, + "TT": 14, + "AG": 15, + "CC": 16, + "CGG": 17, + "CT": 18, + "AT": 19, + "CAG": 20, + "TGG": 21, + "CCG": 22, + "CCA": 23, + "CTG": 24, + "TCG": 25, + "CTT": 26, + "AAG": 27, + "AGG": 28, + "ACG": 29, + "ATT": 30, + "ATG": 31, + "CCGG": 32, + "TTG": 33, + "ACA": 34, + "TCA": 35, + "CAGG": 36, + "CGCG": 37, + "CGGG": 38, + "CTGG": 39, + "TAA": 40, + "ACC": 41, + "CTCG": 42, + "CCAG": 43, + "TCC": 44, + "TAG": 45, + "GG": 46, + "AAAA": 47, + "ACT": 48, + "TAT": 49, + "TCT": 50, + "ATGG": 51, + "CGGCG": 52, + "CCCG": 53, + "TTTT": 54, + "ATCG": 55, + "CCTG": 56, + "ACCG": 57, + "TCGG": 58, + "CACG": 59, + "TTGG": 60, + "CTTG": 61, + "ACGG": 62, + "CAAG": 63, + "CAAA": 64, + "AAGG": 65, + "ACCA": 66, + "AGCG": 67, + "TCCG": 68, + "TGGG": 69, + "CATG": 70, + "TTCG": 71, + "ATTG": 72, + "ACTT": 73, + "TCTT": 74, + "TCCA": 75, + "ACAG": 76, + "TTTG": 77, + "TATT": 78, + "ATCA": 79, + "ATAA": 80, + "AGGG": 81, + "TCAG": 82, + "CCAGG": 83, + "CCGCG": 84, + "AGAA": 85, + "ACTG": 86, + "TGCG": 87, + "CTCA": 88, + "CCTT": 89, + "CCCA": 90, + "CCGGG": 91, + "TCTG": 92, + "TGAA": 93, + "AGCA": 94, + "TTCA": 95, + "CCTCG": 96, + "TACA": 97, + "AACG": 98, + "AATT": 99, + "AAAG": 100, + "TACG": 101, + "CAGCG": 102, + "CGGGG": 103, + "TATG": 104, + "AGAG": 105, + "CCCGG": 106, + "CCTGG": 107, + "AATG": 108, + "TAGG": 109, + "CGAG": 110, + "ATCT": 111, + "CATT": 112, + "ATAG": 113, + "CTGGG": 114, + "TAAG": 115, + "CACA": 116, + "CCGCCG": 117, + "ACCGG": 118, + "TGTG": 119, + "CTCT": 120, + "TCGCG": 121, + "TGGCG": 122, + "CAGGG": 123, + "CTGCG": 124, + "AACA": 125, + "CTCGG": 126, + "CCGAG": 127, + "TGAG": 128, + "CTTCG": 129, + "TGCA": 130, + "AAAT": 131, + "ATTTT": 132, + "TGTT": 133, + "CCACG": 134, + "CCGGCG": 135, + "CCT": 136, + "CCCT": 137, + "CGGCA": 138, + "ACCAG": 139, + "CCTTG": 140, + "ATAT": 141, + "ACGCG": 142, + "AGTT": 143, + "AGGCG": 144, + "CGGTG": 145, + "TCGAG": 146, + "TCGGG": 147, + "CCCAG": 148, + "CCCCG": 149, + "TACC": 150, + "GGG": 151, + "CGGCGG": 152, + "ACGGG": 153, + "ACTGG": 154, + "TCCGG": 155, + "TGCCG": 156, + "TACT": 157, + "TGAT": 158, + "CAGCA": 159, + "CGCA": 160, + "CCCTG": 161, + "CTAA": 162, + "CCGCA": 163, + "TCCAG": 164, + "CTTTT": 165, + "CGCGCG": 166, + "TGCTG": 167, + "CCTCA": 168, + "ACGAG": 169, + "CTTCA": 170, + "ATATT": 171, + "TCTCG": 172, + "ACAGG": 173, + "TGCT": 174, + "AAATT": 175, + "ATGGG": 176, + "TCTGG": 177, + "TCAGG": 178, + "ATGCG": 179, + "AAGCG": 180, + "ACTCG": 181, + "CCTCC": 182, + "TCGGCG": 183, + "CCAAG": 184, + "CATCG": 185, + "ATCGG": 186, + "CTTGG": 187, + "TTAA": 188, + "CCGTG": 189, + "AAGAA": 190, + "ATCAG": 191, + "CCCC": 192, + "CGGAG": 193, + "TGATG": 194, + "AAGGG": 195, + "ACCCG": 196, + "ACGGCG": 197, + "ATCTG": 198, + "AGGAG": 199, + "TGGGG": 200, + "CTAG": 201, + "TCACG": 202, + "CCATG": 203, + "CCGAA": 204, + "CGGGCG": 205, + "TAAAA": 206, + "CCAAA": 207, + "TCCCG": 208, + "ATTGG": 209, + "CTGCA": 210, + "TTGGG": 211, + "CCCGCG": 212, + "TTGCG": 213, + "CTCCG": 214, + "TCGCCG": 215, + "CGGCCG": 216, + "ATCCG": 217, + "ATCTT": 218, + "TGGTG": 219, + "ATGAA": 220, + "TTTTG": 221, + "AAGAG": 222, + "CTCCA": 223, + "ACCTG": 224, + "CCCCA": 225, + "AGGGG": 226, + "CCAGCG": 227, + "ACAAG": 228, + "ACAAA": 229, + "CATCA": 230, + "TGGAG": 231, + "TTCT": 232, + "ATTCG": 233, + "ACACG": 234, + "TCGTCG": 235, + "CTTTG": 236, + "ATCCA": 237, + "CCGACG": 238, + "CTGGCG": 239, + "TTAG": 240, + "CTCC": 241, + "TGAAG": 242, + "CGGAA": 243, + "TGACG": 244, + "ATGAG": 245, + "TTTCA": 246, + "TCGAA": 247, + "TGCAG": 248, + "CACCG": 249, + "AGGAA": 250, + "TTGAA": 251, + "CCAGGG": 252, + "TACTT": 253, + "TGGAA": 254, + "CTGCTG": 255, + "CAAT": 256, + "CTCTT": 257, + "ACGAA": 258, + "TGCGG": 259, + "CTCAG": 260, + "TCAAG": 261, + "TAATT": 262, + "CTGAA": 263, + "CTCGCG": 264, + "ACCGCG": 265, + "CCCTT": 266, + "TCAAA": 267, + "CCGGGG": 268, + "ATCGCG": 269, + "CAAGG": 270, + "TGTTG": 271, + "TCGACG": 272, + "AAAAAA": 273, + "CAGAA": 274, + "CCATT": 275, + "TGGCA": 276, + "TATCG": 277, + "CAGGCG": 278, + "CCGCGG": 279, + "CTGAG": 280, + "ATCC": 281, + "ATTTG": 282, + "AAGTT": 283, + "CCGTCG": 284, + "CAACG": 285, + "TACCA": 286, + "CAGAG": 287, + "CAACA": 288, + "TTGAG": 289, + "TGTCG": 290, + "TATGG": 291, + "ATTAA": 292, + "CACCA": 293, + "ACGACG": 294, + "CTCTG": 295, + "TACAG": 296, + "ATGTT": 297, + "CCGAGG": 298, + "CAGCAG": 299, + "TAAAG": 300, + "CCTCGG": 301, + "CAAAG": 302, + "TACCG": 303, + "TCCTG": 304, + "TACTG": 305, + "TCTTG": 306, + "CCGTT": 307, + "CGAA": 308, + "ACATT": 309, + "CCCTCG": 310, + "CGGTCG": 311, + "TTGTT": 312, + "CCTTCG": 313, + "ACCTT": 314, + "CCGCCA": 315, + "TACGG": 316, + "CTACG": 317, + "CTGTT": 318, + "ACCAGG": 319, + "ATGGCG": 320, + "AGGTG": 321, + "CATGG": 322, + "ATATG": 323, + "CAATT": 324, + "CTATT": 325, + "TCGTG": 326, + "CCTGCG": 327, + "TCATT": 328, + "TCCGCG": 329, + "CGGTT": 330, + "CATTG": 331, + "CAATG": 332, + "CTAT": 333, + "TTTTTT": 334, + "CGCGAG": 335, + "TCGAGG": 336, + "TAGCG": 337, + "AAGGCG": 338, + "TCCTT": 339, + "CCCTGG": 340, + "CAGTT": 341, + "TGGGCG": 342, + "TGGTT": 343, + "CCTCT": 344, + "CTACA": 345, + "ATAAAA": 346, + "CCGCTG": 347, + "CTCGAG": 348, + "CACGG": 349, + "TATAA": 350, + "CCATCG": 351, + "AAGAAG": 352, + "ATACA": 353, + "CCCGGG": 354, + "AGTG": 355, + "CCCAGG": 356, + "ACCGGG": 357, + "CCCCGG": 358, + "ACGCCG": 359, + "ATCTCG": 360, + "ACTTG": 361, + "CCGATG": 362, + "TATTG": 363, + "TCATG": 364, + "TAGAA": 365, + "AGGGCG": 366, + "ACCTCG": 367, + "ACGTG": 368, + "AAGCA": 369, + "CGGTGG": 370, + "TTGGCG": 371, + "CGGCTG": 372, + "CGGCAG": 373, + "ATCGAG": 374, + "CCACA": 375, + "TAGAG": 376, + "CGGCCA": 377, + "CCGGAG": 378, + "AGGTT": 379, + "TCCAGG": 380, + "TCGTT": 381, + "ATTCA": 382, + "CCTCCG": 383, + "ACATG": 384, + "ATAAG": 385, + "CGGGGG": 386, + "TCAGCG": 387, + "TCTTCG": 388, + "TAAGG": 389, + "TCCTCG": 390, + "CCCGAG": 391, + "CTATG": 392, + "CGGCGCG": 393, + "ATCCGG": 394, + "CTGCCG": 395, + "CCTGGG": 396, + "ATACG": 397, + "TGGTGG": 398, + "AAGTG": 399, + "TCGATG": 400, + "CCTTGG": 401, + "AAAATT": 402, + "CAGTG": 403, + "CCACCA": 404, + "CCGGCA": 405, + "CCGGTG": 406, + "ACCTGG": 407, + "CTCGGG": 408, + "ATGATG": 409, + "ATCAGG": 410, + "ACGAGG": 411, + "TCGGGG": 412, + "AAAAAG": 413, + "TCCGGG": 414, + "CCCACG": 415, + "TTGCA": 416, + "CCGAAG": 417, + "CTGGGG": 418, + "ACCCA": 419, + "TATCA": 420, + "ATGCA": 421, + "TAATG": 422, + "AGGCA": 423, + "ACGTT": 424, + "AGCAG": 425, + "AAAAG": 426, + "TAGGG": 427, + "CTGTG": 428, + "CCGCAG": 429, + "CCTCCA": 430, + "TCATCG": 431, + "TATTTT": 432, + "TCCCA": 433, + "ATCTGG": 434, + "CTTCTT": 435, + "TAACG": 436, + "CAAGCG": 437, + "ATGTG": 438, + "CGGCT": 439, + "CCCTTG": 440, + "CCGCT": 441, + "ATTTTG": 442, + "TAGTT": 443, + "ATCACG": 444, + "ACCACG": 445, + "CCATCA": 446, + "AGAAG": 447, + "AGGAGG": 448, + "TCGCGG": 449, + "TCGCA": 450, + "AGCTG": 451, + "ACTTCG": 452, + "CCGTGG": 453, + "ACGCA": 454, + "ATTATT": 455, + "CCTAA": 456, + "ATCCCG": 457, + "TCATCA": 458, + "CTTGCG": 459, + "ATCAAA": 460, + "CCAGCA": 461, + "CTCGGCG": 462, + "ATAGG": 463, + "TTGTG": 464, + "AATAA": 465, + "ACAGCG": 466, + "ACGTCG": 467, + "CCTTTG": 468, + "CCCATG": 469, + "CAGCGG": 470, + "ACGATG": 471, + "CCCCCG": 472, + "ATCGGG": 473, + "CCACCG": 474, + "TGGCGG": 475, + "CCTAT": 476, + "CCTTTT": 477, + "ACTCA": 478, + "CTCCGG": 479, + "TTCTT": 480, + "ATTTAA": 481, + "ACGGGG": 482, + "AGCGG": 483, + "CTCCAG": 484, + "ATCTTG": 485, + "TCTCA": 486, + "CCAAGG": 487, + "ATGAAG": 488, + "CCCGGCG": 489, + "TCCTGG": 490, + "TGAGG": 491, + "ACTAA": 492, + "ATTAG": 493, + "CAGCCG": 494, + "CTGGAG": 495, + "TCCACG": 496, + "ACATCG": 497, + "CTTAA": 498, + "TATAG": 499, + "ATCAAG": 500, + "ATCCTG": 501, + "TTGTTG": 502, + "ATCCAG": 503, + "CTGCGG": 504, + "ATGCCG": 505, + "CTCCTG": 506, + "TAATAA": 507, + "ACTGGG": 508, + "TCGAAG": 509, + "CTCTCG": 510, + "CAGGGG": 511, + "TGGCCG": 512, + "ATATTG": 513, + "ATTTTTT": 514, + "CCCCAG": 515, + "TCTAA": 516, + "ATTTCA": 517, + "ACGAAG": 518, + "CTGCAG": 519, + "ACGCGG": 520, + "TTCGG": 521, + "TTTCG": 522, + "CCGCCGG": 523, + "TGCCA": 524, + "ATCATG": 525, + "ACCTTG": 526, + "ACACA": 527, + "ACATCA": 528, + "CCGCGCG": 529, + "ATAATT": 530, + "AATTG": 531, + "CTCAAG": 532, + "TCTGCG": 533, + "TCCTTG": 534, + "ATACT": 535, + "AAATG": 536, + "AGGCGG": 537, + "CAGGAG": 538, + "ACCCGG": 539, + "CTTTTG": 540, + "CTGAAG": 541, + "CCGGGCG": 542, + "TTTGG": 543, + "CTACT": 544, + "TGCGCG": 545, + "CGGCGAG": 546, + "CAAAAG": 547, + "CTGATG": 548, + "CCGGAA": 549, + "TGTGG": 550, + "CCATGG": 551, + "CCTCTT": 552, + "ATGGGG": 553, + "TCGGCA": 554, + "AGGTCG": 555, + "CATGCG": 556, + "ACAACA": 557, + "CTCCCG": 558, + "CTTCGG": 559, + "TTCCA": 560, + "CCGTCA": 561, + "AGGAAG": 562, + "TCTGGG": 563, + "CCGTTG": 564, + "CGCGCA": 565, + "CTCACG": 566, + "CCGGCGG": 567, + "CCGACA": 568, + "CCCAAG": 569, + "CTGGAA": 570, + "TGGTCG": 571, + "ACCGAG": 572, + "ACGCTG": 573, + "CGCGAA": 574, + "CTCGAA": 575, + "AGCGAG": 576, + "TCACA": 577, + "TAGCA": 578, + "CTCTTG": 579, + "TCAGGG": 580, + "CTGGTG": 581, + "CAGGAA": 582, + "ACGGCA": 583, + "TTCAG": 584, + "TTTAA": 585, + "TTGGGG": 586, + "TTGATG": 587, + "CTAAG": 588, + "TGATT": 589, + "TTGAAG": 590, + "CCCCTG": 591, + "CCACGG": 592, + "CCTACG": 593, + "CCAAAG": 594, + "CCTAG": 595, + "CACGAG": 596, + "CAAACG": 597, + "CGGGAG": 598, + "CAGAAG": 599, + "ACAGGG": 600, + "TACCGG": 601, + "TTCGAG": 602, + "ATTGCG": 603, + "AGGCCG": 604, + "TAACA": 605, + "TGCTT": 606, + "ATCGAA": 607, + "CCAACG": 608, + "TTTTCG": 609, + "CTCTGG": 610, + "CTACC": 611, + "CAGCTG": 612, + "ACTGCG": 613, + "TGCTCG": 614, + "ATACC": 615, + "ATATAA": 616, + "CGGACG": 617, + "CCTTCA": 618, + "TAAATT": 619, + "CCAACA": 620, + "CCATTG": 621, + "TCGCTG": 622, + "AAGGAG": 623, + "CGGGCA": 624, + "CAGCGCG": 625, + "CCCGCA": 626, + "ATGGAG": 627, + "TTCTG": 628, + "TCCCGG": 629, + "ATGTCG": 630, + "CTAAAA": 631, + "ATGCTG": 632, + "CTTTCA": 633, + "TGGAAG": 634, + "AGAACG": 635, + "CCCAAA": 636, + "AAACA": 637, + "TCGGTG": 638, + "TGAACG": 639, + "CGGAAG": 640, + "CCTCTG": 641, + "AATCG": 642, + "CTTAG": 643, + "CTCGCCG": 644, + "AAAACG": 645, + "TACTGG": 646, + "AATGG": 647, + "TAGGCG": 648, + "TTATT": 649, + "TTCCG": 650, + "CTCAGG": 651, + "CGGTCA": 652, + "TGACA": 653, + "CGCGCCG": 654, + "ATCGGCG": 655, + "CTCATG": 656, + "CTCAAA": 657, + "AATCA": 658, + "TACCAG": 659, + "ATGACG": 660, + "AGAAAG": 661, + "ACCTCA": 662, + "ATAAAG": 663, + "TCTAG": 664, + "ATATCG": 665, + "CTTTGG": 666, + "ATGTTG": 667, + "CCTGCA": 668, + "CTTCAG": 669, + "CGGAGG": 670, + "CCCTCA": 671, + "CCTCAG": 672, + "CTCGACG": 673, + "CTGGGCG": 674, + "TCCTCA": 675, + "TGTCA": 676, + "CTGTTG": 677, + "ATTTCG": 678, + "CTGACG": 679, + "TTTGCG": 680, + "TGTAG": 681, + "TACTCG": 682, + "AGGACG": 683, + "TCGGAG": 684, + "TGCCGG": 685, + "AACAG": 686, + "ATGCGG": 687, + "CTTTCG": 688, + "AGGTGG": 689, + "CTTGGG": 690, + "CTTCCA": 691, + "TCTTTT": 692, + "CCAGAA": 693, + "CCAGGCG": 694, + "ACAAAG": 695, + "CCAGAG": 696, + "TTGCCG": 697, + "CTGTCG": 698, + "CTGCGCG": 699, + "TGCTGG": 700, + "ACTAG": 701, + "CTTGAG": 702, + "TATATT": 703, + "CGGCCGG": 704, + "ACAAGG": 705, + "TAAAAG": 706, + "TAAAAAA": 707, + "CCTCGCG": 708, + "AAAGG": 709, + "TGATCG": 710, + "CCTACA": 711, + "ACCAAG": 712, + "CAGCCA": 713, + "ACCGGCG": 714, + "CTTCT": 715, + "ACTTTT": 716, + "TACGCG": 717, + "CTTCTG": 718, + "TCGCCA": 719, + "TCTTCA": 720, + "ATATCA": 721, + "CGGCGGCG": 722, + "CGGATG": 723, + "CCGGCCG": 724, + "CAAGAA": 725, + "CTCGTCG": 726, + "CGGCGGG": 727, + "CCCGAA": 728, + "CAGATG": 729, + "ATTGAA": 730, + "ACGCCA": 731, + "ATTGGG": 732, + "ATGGAA": 733, + "ACGACA": 734, + "CCCCCA": 735, + "TTTTTG": 736, + "TCTTGG": 737, + "ACGTGG": 738, + "ACGGAG": 739, + "CTGCCA": 740, + "CAAGAG": 741, + "TACAGG": 742, + "TCGTCA": 743, + "CTGCTCG": 744, + "ATCTCA": 745, + "AAGCCG": 746, + "AGCGCA": 747, + "CCGCGAG": 748, + "TTTTCA": 749, + "TAGTG": 750, + "CTAGG": 751, + "CAAATT": 752, + "TCGTGG": 753, + "TTTTAA": 754, + "TCCGAG": 755, + "TATTCG": 756, + "ATTTGG": 757, + "CAGGGCG": 758, + "ACCGCA": 759, + "TCAGCA": 760, + "CGGGAA": 761, + "CTTCCG": 762, + "TTGGAG": 763, + "TAGAAG": 764, + "CCTGGCG": 765, + "AAGGAA": 766, + "CAGCT": 767, + "AAAACA": 768, + "AGGATG": 769, + "TTCGCG": 770, + "TTGCTG": 771, + "TCACCG": 772, + "ATGGCA": 773, + "TCTCGG": 774, + "CTGGCA": 775, + "ACGGTG": 776, + "CTTTAA": 777, + "ACCCCG": 778, + "CCAATG": 779, + "CGGGGCG": 780, + "CTTGAA": 781, + "CCCGCCG": 782, + "ACATGG": 783, + "AAGATG": 784, + "TCCCAG": 785, + "TCCGGCG": 786, + "TTTCT": 787, + "ACTTCA": 788, + "CTGCT": 789, + "CGGCTT": 790, + "ATGGTG": 791, + "ATACCA": 792, + "CGGTTG": 793, + "ATAGAA": 794, + "CCTATG": 795, + "ACCCAG": 796, + "TTTGAA": 797, + "ATCGTG": 798, + "TCTCCA": 799, + "ACAGCA": 800, + "AAAATG": 801, + "CCTGAA": 802, + "ACATTG": 803, + "CGGGTG": 804, + "AGGGGG": 805, + "ATCATT": 806, + "CAGTTG": 807, + "TGAAAG": 808, + "ACAATT": 809, + "ATACTT": 810, + "CACGAA": 811, + "CCCAGCG": 812, + "ATCGCCG": 813, + "ATACCG": 814, + "CCTGAG": 815, + "TCGTTG": 816, + "CTGCTGG": 817, + "ATCCCA": 818, + "ATGATT": 819, + "TACGGG": 820, + "AAAAATT": 821, + "ACGTCA": 822, + "ACGTTG": 823, + "CAGGTG": 824, + "ATTGAG": 825, + "CAGCTT": 826, + "TGGTCA": 827, + "TGGGGG": 828, + "CTCCTCG": 829, + "TGGATG": 830, + "TGGCTG": 831, + "ACCAAA": 832, + "CAGGCA": 833, + "TCCGCA": 834, + "CCAATT": 835, + "CTCCTT": 836, + "TGGAGG": 837, + "ATCGCA": 838, + "ATATGG": 839, + "AAGCTG": 840, + "TGCGAG": 841, + "TAATTG": 842, + "CGCGTG": 843, + "TGGGAG": 844, + "CTTTTTT": 845, + "ACAACG": 846, + "CTGGCCG": 847, + "AGGTCA": 848, + "ACACCG": 849, + "AGGTTG": 850, + "TCCAAG": 851, + "AAGGCA": 852, + "TCCCCG": 853, + "TGGACG": 854, + "CCGGTT": 855, + "TGGCCA": 856, + "CATGAA": 857, + "TAGCCG": 858, + "TCAAAG": 859, + "TCTCCG": 860, + "TCGGCGG": 861, + "CAGACG": 862, + "TTGGAA": 863, + "TGCGCA": 864, + "ACACCA": 865, + "CAAGCA": 866, + "ATTTAT": 867, + "CCTCGGCG": 868, + "ACAATG": 869, + "CAGCAGG": 870, + "ACCCTG": 871, + "AAGGGG": 872, + "CAGCTCG": 873, + "TCCTCC": 874, + "CCCGTG": 875, + "ATATTTT": 876, + "CGGCTCG": 877, + "CGCGACG": 878, + "CATGAG": 879, + "ATACTG": 880, + "AGCGTG": 881, + "CCTATT": 882, + "CCAGTT": 883, + "AAGGTG": 884, + "TGGTTG": 885, + "TAGATG": 886, + "CAAACA": 887, + "AAGCGG": 888, + "TCCAAA": 889, + "CAGTCG": 890, + "ATCCTT": 891, + "AAAATAA": 892, + "AAGTTG": 893, + "TTTAT": 894, + "CCGCTCG": 895, + "TAGTTG": 896, + "AACGAG": 897, + "CCCCTT": 898, + "AGGGAG": 899, + "TTTGAG": 900, + "AAGACG": 901, + "CGCGCGG": 902, + "CTCCCA": 903, + "CTACCG": 904, + "CCGCTT": 905, + "TGGCAG": 906, + "CCGGTCG": 907, + "TCAAGG": 908, + "CTATTG": 909, + "CACGCCG": 910, + "ATCAGCG": 911, + "TAAATG": 912, + "TCACCA": 913, + "AAGAGG": 914, + "ATTCTT": 915, + "ATACAG": 916, + "TGGGCA": 917, + "CGGGCGG": 918, + "AGAATT": 919, + "ACTTGG": 920, + "AAGTCG": 921, + "TATTAA": 922, + "CCGGCGCG": 923, + "ACCGTG": 924, + "TACCCG": 925, + "CCCCGCG": 926, + "TACACG": 927, + "GGCG": 928, + "CACGCA": 929, + "CTGCTT": 930, + "CCGCCCG": 931, + "AAGATT": 932, + "TCATTG": 933, + "CCCTCGG": 934, + "ACGGAA": 935, + "AAAGAG": 936, + "TAGTAG": 937, + "AGCGAA": 938, + "TTGGCA": 939, + "TTGGTG": 940, + "ACCAGCG": 941, + "AGGGCA": 942, + "ATTGTT": 943, + "CGCGTCG": 944, + "ATGAGG": 945, + "CTCGCA": 946, + "TAATTTT": 947, + "CTCGTG": 948, + "TCTGCA": 949, + "TCAACA": 950, + "ACCGAA": 951, + "ATGCAG": 952, + "TATTGG": 953, + "ATCCGCG": 954, + "TCTTTG": 955, + "ATTCCA": 956, + "ATCGTCG": 957, + "TTTGTT": 958, + "CCAGCAG": 959, + "CTACGG": 960, + "CCTCGGG": 961, + "AGGCCA": 962, + "TATGGG": 963, + "TATTTG": 964, + "ATGCCA": 965, + "ACTCCA": 966, + "TCGGGCG": 967, + "CTACTT": 968, + "AGGCTG": 969, + "AATTAA": 970, + "TCGGAA": 971, + "TAATCA": 972, + "TCTCTT": 973, + "AAGCAG": 974, + "CGGCTGG": 975, + "TTCATT": 976, + "GGGG": 977, + "TTTTAG": 978, + "AAAAAAAA": 979, + "TTCGAA": 980, + "CGGCCAG": 981, + "CCTGTT": 982, + "ATAGCG": 983, + "CAGTGG": 984, + "TCAACG": 985, + "ACTATT": 986, + "ACCCCA": 987, + "ATATAG": 988, + "ATACGG": 989, + "TATCTT": 990, + "CTCCGCG": 991, + "CTGGTT": 992, + "TCAATT": 993, + "TCATGG": 994, + "CGCGCGCG": 995, + "CTATCG": 996, + "CCGAGCG": 997, + "ATAACG": 998, + "CCTCGAG": 999, + "TCGACA": 1000, + "CTCTCA": 1001, + "CTGCCGG": 1002, + "TACAAA": 1003, + "ATTGCA": 1004, + "CAAATG": 1005, + "CTACCA": 1006, + "ATAGAG": 1007, + "TCGCCGG": 1008, + "CTGATT": 1009, + "ACTACA": 1010, + "ACTCGG": 1011, + "TTTCC": 1012, + "CTGGCGG": 1013, + "CTTGCA": 1014, + "CTGTGG": 1015, + "CTTCGCG": 1016, + "TCTATT": 1017, + "ATCGACG": 1018, + "CTCGAGG": 1019, + "ACTACG": 1020, + "TCCATG": 1021, + "CAGATT": 1022, + "TCAGAA": 1023, + "CCGCCAG": 1024, + "TATTCA": 1025, + "CTGGTCG": 1026, + "CCCACA": 1027, + "TACGAG": 1028, + "TAGTCG": 1029, + "CTACTG": 1030, + "ACAGAA": 1031, + "TTGTCG": 1032, + "CGGCACG": 1033, + "CTAAAG": 1034, + "CCCTCT": 1035, + "CCGACC": 1036, + "CAGCACG": 1037, + "TACAAG": 1038, + "CTCGCGG": 1039, + "AAAAAAG": 1040, + "TGAATT": 1041, + "TCCGAA": 1042, + "ATGGTT": 1043, + "TCTACA": 1044, + "TAGAGG": 1045, + "TTTGCA": 1046, + "CAGAGG": 1047, + "TTGATT": 1048, + "TGGGAA": 1049, + "CAGGTT": 1050, + "ACCATG": 1051, + "CTGATCG": 1052, + "TTGACG": 1053, + "TCCCCA": 1054, + "ACCAGGG": 1055, + "TAAACA": 1056, + "AAGCCA": 1057, + "ACAGAG": 1058, + "CCTCCGG": 1059, + "CGGGCCG": 1060, + "CCAGTG": 1061, + "TCAATG": 1062, + "ACGGCGG": 1063, + "TATGCG": 1064, + "CAGCCGG": 1065, + "ACTTTG": 1066, + "ATAAGG": 1067, + "CTTGTT": 1068, + "AGAGAG": 1069, + "CATGCA": 1070, + "CGGGTT": 1071, + "TCTACG": 1072, + "CTGAGG": 1073, + "ACCTCGG": 1074, + "CGGCGAA": 1075, + "AGAACA": 1076, + "CTATCA": 1077, + "CGCGTT": 1078, + "CGGCCCG": 1079, + "CAGGTCG": 1080, + "TATCCA": 1081, + "CCTCCAG": 1082, + "ATCGAGG": 1083, + "CAGGCCG": 1084, + "CTAATT": 1085, + "TGGATT": 1086, + "ACGCCGG": 1087, + "TCCAGCG": 1088, + "CAAGTT": 1089, + "ACTGCA": 1090, + "TTGCGG": 1091, + "TCAGAG": 1092, + "CTCGATG": 1093, + "CTTATT": 1094, + "ATCCTCG": 1095, + "CCCTGCG": 1096, + "TGGGTG": 1097, + "TCCACA": 1098, + "TAGGGG": 1099, + "ACGGGCG": 1100, + "TCTGAA": 1101, + "TTGGTT": 1102, + "CTTGGCG": 1103, + "CCGATT": 1104, + "CCGCCGCG": 1105, + "TAAGCG": 1106, + "CTTTCT": 1107, + "TAGATT": 1108, + "TAGCGG": 1109, + "ACCTCC": 1110, + "ACCACA": 1111, + "TCCATT": 1112, + "TTCGTG": 1113, + "ACGCAG": 1114, + "ATAATG": 1115, + "ACCATT": 1116, + "ACGATT": 1117, + "CTTTAT": 1118, + "CAGCGAG": 1119, + "ATCACA": 1120, + "ATGTGG": 1121, + "ATGACA": 1122, + "ATCGTT": 1123, + "ATATCT": 1124, + "TCCCTG": 1125, + "ACTCCG": 1126, + "TCGAGCG": 1127, + "CCAGCCG": 1128, + "AGGATT": 1129, + "TTGCCA": 1130, + "CCCGTT": 1131, + "CTACAG": 1132, + "CGCGAGG": 1133, + "ATAAATT": 1134, + "TAATAT": 1135, + "CTATGG": 1136, + "CTGGTGG": 1137, + "TAATAG": 1138, + "ATAGCA": 1139, + "CCGGGGG": 1140, + "CGGCGCA": 1141, + "CCTTGCG": 1142, + "CGCGCTG": 1143, + "AAGTGG": 1144, + "CTCCAGG": 1145, + "ATCCCGG": 1146, + "CCGGTGG": 1147, + "ATCGCGG": 1148, + "CTCGTT": 1149, + "ACTGAA": 1150, + "CCCGACG": 1151, + "TTGCAG": 1152, + "CCGGCCA": 1153, + "TGAACA": 1154, + "CCTGCTG": 1155, + "AAGGTT": 1156, + "CGGATT": 1157, + "TCCTCGG": 1158, + "AGGGAA": 1159, + "TAAAGG": 1160, + "CTAATG": 1161, + "CCCCCGG": 1162, + "TAGCTG": 1163, + "TAGACG": 1164, + "ATGTCA": 1165, + "ATCGGCA": 1166, + "TTGAGG": 1167, + "CCACTG": 1168, + "TAAGGG": 1169, + "TTCGCA": 1170, + "CTCCTGG": 1171, + "CCCATT": 1172, + "ACAAAAA": 1173, + "AGGGTG": 1174, + "TATGAA": 1175, + "CCAGCGG": 1176, + "TTTTTTTT": 1177, + "CCGCTGG": 1178, + "CCGGCAG": 1179, + "CTCATT": 1180, + "ACCTGCG": 1181, + "TCACGG": 1182, + "ATAACA": 1183, + "AAGAAAA": 1184, + "AGCACA": 1185, + "TATCTG": 1186, + "ACTCTT": 1187, + "TCGCAG": 1188, + "ACCGCCG": 1189, + "AGCATT": 1190, + "CCGCGCA": 1191, + "ATGGGCG": 1192, + "TAAAATT": 1193, + "CTTGCCG": 1194, + "ATCCTGG": 1195, + "CACGACG": 1196, + "TCTCTG": 1197, + "CTTCGAG": 1198, + "TGCGAA": 1199, + "CAGGCGG": 1200, + "AAGACA": 1201, + "TCCGTG": 1202, + "TCGATT": 1203, + "CCCGCGG": 1204, + "TCTGAG": 1205, + "TAAGAA": 1206, + "TATTAG": 1207, + "CCCTTCG": 1208, + "AGCGCCG": 1209, + "TGCGTG": 1210, + "AGGACA": 1211, + "ACTGAG": 1212, + "ATCTTCG": 1213, + "CTTTAG": 1214, + "CTCGAAG": 1215, + "CTATAA": 1216, + "CCACAG": 1217, + "CCCGTCG": 1218, + "CCATCT": 1219, + "CGGGTCG": 1220, + "CGGCGACG": 1221, + "CCATCC": 1222, + "CACGTCG": 1223, + "TCGGCCG": 1224, + "CCCGGGG": 1225, + "AGGCAG": 1226, + "CCCCAGG": 1227, + "AAAGTT": 1228, + "ATCCAGG": 1229, + "CCTGTG": 1230, + "CTCTTCG": 1231, + "CGGCGTG": 1232, + "TTTTTTG": 1233, + "AAGTAA": 1234, + "AGAATG": 1235, + "CCGGCTG": 1236, + "CCGACGG": 1237, + "AGCGCGG": 1238, + "AATGAG": 1239, + "AACGAA": 1240, + "TAGTAA": 1241, + "CACGTG": 1242, + "CCCCTCG": 1243, + "CCCAGGG": 1244, + "TAGGAG": 1245, + "CATGTT": 1246, + "TATATG": 1247, + "ACCTCT": 1248, + "CCCCCT": 1249, + "CGGACA": 1250, + "CCCTGGG": 1251, + "CGCGATG": 1252, + "ATCCGGG": 1253, + "TTTTTAA": 1254, + "ATCATCG": 1255, + "CCCCGGG": 1256, + "CCGCCGAG": 1257, + "TGGACA": 1258, + "CGGATCG": 1259, + "ATCTAA": 1260, + "ATAATAA": 1261, + "CGCGCAG": 1262, + "CTTTCC": 1263, + "CGGCAGG": 1264, + "AAGTCA": 1265, + "ATTTCT": 1266, + "CGGCCTG": 1267, + "TAGCCA": 1268, + "TCGGTT": 1269, + "TATCAG": 1270, + "CGCGCCA": 1271, + "CCCGAGG": 1272, + "TAATCG": 1273, + "CGGCGCCG": 1274, + "ATGAAAA": 1275, + "CCTCCCG": 1276, + "ACGGTT": 1277, + "ATCATCA": 1278, + "CCGCGAA": 1279, + "TCAGTT": 1280, + "ACTCTG": 1281, + "AAATATT": 1282, + "CACGTT": 1283, + "ACCGTT": 1284, + "ATCGCCA": 1285, + "CTCGGGG": 1286, + "CATTAA": 1287, + "CAGACA": 1288, + "TTTGTG": 1289, + "TCCGCCG": 1290, + "ATAGTT": 1291, + "CTCATCG": 1292, + "CAAAATT": 1293, + "CTTGTG": 1294, + "TAATGG": 1295, + "CTCAGCG": 1296, + "CTGACA": 1297, + "CCAGCGCG": 1298, + "TATAAAA": 1299, + "CCTGGGG": 1300, + "TCCAGGG": 1301, + "CTGTCA": 1302, + "CCGCGCCG": 1303, + "AAGGGCG": 1304, + "CCCGCGCG": 1305, + "TATACA": 1306, + "TATTTTTT": 1307, + "TCTGTT": 1308, + "ACTATG": 1309, + "ACGACC": 1310, + "ATCTGCG": 1311, + "CGGCGTCG": 1312, + "TTCGCCG": 1313, + "TAGCAG": 1314, + "CCTGCCG": 1315, + "CAAGTG": 1316, + "CTCCCGG": 1317, + "ATTGTG": 1318, + "CTCGGCA": 1319, + "CTGCCCG": 1320, + "ACGGCCG": 1321, + "CGGGCGCG": 1322, + "CCGGCGAG": 1323, + "CTCGCCA": 1324, + "TCTATG": 1325, + "TGAATG": 1326, + "TCGGCCA": 1327, + "CTCCGGG": 1328, + "ACCCGCG": 1329, + "CGGCAAG": 1330, + "AACGCA": 1331, + "AAGTAG": 1332, + "TTCGTT": 1333, + "TGGGTT": 1334, + "AAGCTT": 1335, + "CCGGACG": 1336, + "ACCGGGG": 1337, + "CCCGCCA": 1338, + "TTGTGG": 1339, + "CTTCTCG": 1340, + "AGGGTT": 1341, + "CCCCTGG": 1342, + "AATTAG": 1343, + "TTTTTCA": 1344, + "CTTTTTG": 1345, + "ATTCTG": 1346, + "AGCGTT": 1347, + "ACAGTT": 1348, + "CACACA": 1349, + "ATGTAA": 1350, + "TATGAG": 1351, + "TCCGTT": 1352, + "TACGGCG": 1353, + "TACATT": 1354, + "CCGATCG": 1355, + "ATCTTTT": 1356, + "TTTTATT": 1357, + "TGCAGG": 1358, + "AAACG": 1359, + "CTGCAGG": 1360, + "TTCACA": 1361, + "CTTCTTG": 1362, + "TAGTGG": 1363, + "TCCTCT": 1364, + "CCAGGGG": 1365, + "CCCCGAG": 1366, + "TCGCGCG": 1367, + "CAGTCA": 1368, + "CAGCGGG": 1369, + "CCAGGAG": 1370, + "CTCACA": 1371, + "TAAGAG": 1372, + "ACATAA": 1373, + "AACGG": 1374, + "TACTTG": 1375, + "ATGTAG": 1376, + "CTTCCTG": 1377, + "CCGGCCGG": 1378, + "CCTTGGG": 1379, + "ATCAGCA": 1380, + "ATGCTT": 1381, + "GGGCG": 1382, + "TATCGG": 1383, + "TACCTG": 1384, + "CCGCCTG": 1385, + "ATGGCGG": 1386, + "ATTTAG": 1387, + "TTGTCA": 1388, + "CCGACCG": 1389, + "CTAGAA": 1390, + "CAGCCCG": 1391, + "CCGCGGG": 1392, + "ACACGG": 1393, + "CTGCGGG": 1394, + "TTCGTCG": 1395, + "CAGATCG": 1396, + "AATGTT": 1397, + "CTTCCAG": 1398, + "ATTTTAA": 1399, + "CTGGAGG": 1400, + "TTGTAG": 1401, + "TGGCGCG": 1402, + "TTGTAA": 1403, + "CCGTCGG": 1404, + "CTGGAAG": 1405, + "CTGACCG": 1406, + "CCACCAG": 1407, + "AAAATCA": 1408, + "CATGTG": 1409, + "CCACCGG": 1410, + "TCCTGCG": 1411, + "CCCGGCA": 1412, + "AAAAACA": 1413, + "ACCCTT": 1414, + "ACTGTT": 1415, + "TGGCTT": 1416, + "TATTATT": 1417, + "ACTCAG": 1418, + "CCACTT": 1419, + "CGCGAAG": 1420, + "CGGCGCGG": 1421, + "CAGGAAG": 1422, + "TAAGTT": 1423, + "CTCCTTG": 1424, + "AATGCA": 1425, + "AACGTG": 1426, + "ACGACGG": 1427, + "ATTCAG": 1428, + "ACCTTCG": 1429, + "TCGCGCA": 1430, + "ATTCCG": 1431, + "ACGCGCG": 1432, + "TACATG": 1433, + "CCATAA": 1434, + "ACTGGCG": 1435, + "TCGTAG": 1436, + "CAAAAAG": 1437, + "CCTGGAG": 1438, + "ATCTAG": 1439, + "ATAGGG": 1440, + "CCGGAGG": 1441, + "ACCTGGG": 1442, + "CTGCGCA": 1443, + "TAGGTG": 1444, + "CGGCGAGG": 1445, + "CTGGACG": 1446, + "TCAGTG": 1447, + "CATTAG": 1448, + "CCGTAG": 1449, + "ATTGGCG": 1450, + "ACTACT": 1451, + "TTGCTT": 1452, + "CTGGCCA": 1453, + "CCGTCC": 1454, + "CGGCCGCG": 1455, + "TAGGAA": 1456, + "AAAAATG": 1457, + "CTCAAGG": 1458, + "CTCCACG": 1459, + "CCGGGCA": 1460, + "CCGGGAG": 1461, + "ACTTAA": 1462, + "ATCTTCA": 1463, + "ATTACA": 1464, + "CACGATG": 1465, + "CAGCCAG": 1466, + "TCGTCGG": 1467, + "TATGTT": 1468, + "CAGCTTG": 1469, + "CACGCTG": 1470, + "ATTTCC": 1471, + "CGGGCTG": 1472, + "ACGATCG": 1473, + "CTGGCTG": 1474, + "CGCGCTCG": 1475, + "ATCTGGG": 1476, + "TCTGGCG": 1477, + "TACGAA": 1478, + "CAAGAAG": 1479, + "ATCCGCA": 1480, + "ATCAGGG": 1481, + "ATTCGG": 1482, + "CGGGTGG": 1483, + "AGGTAG": 1484, + "CCATCGG": 1485, + "CCCCGCCG": 1486, + "TTCGACG": 1487, + "ATGCCGG": 1488, + "ATCGGGG": 1489, + "TGGGGCG": 1490, + "TTCATCA": 1491, + "ATTTCTT": 1492, + "CTCGACA": 1493, + "TCCCTT": 1494, + "TATCCG": 1495, + "CCCGCTG": 1496, + "TCAGGCG": 1497, + "CCCCGGCG": 1498, + "TCTCAG": 1499, + "CGGTAG": 1500, + "CCCGGAG": 1501, + "CGGGCAG": 1502, + "CCGCGGCG": 1503, + "CAGCGCA": 1504, + "ACCGGCA": 1505, + "TCCGGGG": 1506, + "ACAGTG": 1507, + "ACCGCGG": 1508, + "CCCATCG": 1509, + "CTAAAT": 1510, + "ACCGTCG": 1511, + "TTGACA": 1512, + "ACGAGCG": 1513, + "ATTTTTG": 1514, + "CCAGGGCG": 1515, + "CCGGTCA": 1516, + "CCAACT": 1517, + "TATGCA": 1518, + "CAGGTGG": 1519, + "TATTTAA": 1520, + "CCTACC": 1521, + "ATCGTCA": 1522, + "CCAACC": 1523, + "AACTG": 1524, + "ATGGTGG": 1525, + "AAAAAATT": 1526, + "CTCGCTG": 1527, + "CGGTCGG": 1528, + "ATTATG": 1529, + "TCTGTG": 1530, + "ATGGCCG": 1531, + "AAAATAT": 1532, + "CCCCACG": 1533, + "TCATAA": 1534, + "CTAACA": 1535, + "ATCAAGG": 1536, + "CTTTCTT": 1537, + "ATCCTCA": 1538, + "CCTTGAG": 1539, + "TGTGCA": 1540, + "CTAGCG": 1541, + "CCATAG": 1542, + "TCGGGGG": 1543, + "TGCGTT": 1544, + "ACCTAA": 1545, + "CAGGAGG": 1546, + "CTAGAG": 1547, + "TCGGCGAG": 1548, + "TGTGAG": 1549, + "TATTTTG": 1550, + "CCTACT": 1551, + "CAGGATG": 1552, + "TCGGCGCG": 1553, + "AAAATTG": 1554, + "AACCA": 1555, + "CTCATCA": 1556, + "CTGGATG": 1557, + "TAAGCA": 1558, + "TTGGGCG": 1559, + "ACATCT": 1560, + "CAAATAA": 1561, + "AGGTAA": 1562, + "CTATAG": 1563, + "TTCATCG": 1564, + "CGGCGATG": 1565, + "CCCGCAG": 1566, + "CTCCCT": 1567, + "CTGCACG": 1568, + "CAGGACG": 1569, + "CTATCT": 1570, + "TGGTAA": 1571, + "ACGGTCG": 1572, + "CTGGGGG": 1573, + "TCATCT": 1574, + "CCGGGGCG": 1575, + "TAGGCA": 1576, + "ACCGACG": 1577, + "CCACGCG": 1578, + "CTCCTCC": 1579, + "ATCGAAG": 1580, + "ATCCCT": 1581, + "CCTGCGCG": 1582, + "TACTCA": 1583, + "CTGTAA": 1584, + "ACCATCG": 1585, + "TATAAG": 1586, + "ATTTATT": 1587, + "TCGGTGG": 1588, + "TGCCCG": 1589, + "CTTCAAG": 1590, + "TCTTAA": 1591, + "CCTGCTCG": 1592, + "AAGGCGG": 1593, + "ATCGATG": 1594, + "CCTGCAG": 1595, + "CTTCGGG": 1596, + "TACACA": 1597, + "AGCGTCG": 1598, + "TAGTCA": 1599, + "CTCTAG": 1600, + "TTCGAGG": 1601, + "CCTAAG": 1602, + "CTTGATG": 1603, + "ATCAACA": 1604, + "CGGTGCG": 1605, + "TCGGTCG": 1606, + "CTGACC": 1607, + "CGCGCCGG": 1608, + "CCCCCAG": 1609, + "ACCGAGG": 1610, + "TACCTT": 1611, + "TAGACA": 1612, + "ATCAATT": 1613, + "CTCGTGG": 1614, + "CCTCACG": 1615, + "ACGCTT": 1616, + "CCCGATG": 1617, + "CCTGCGG": 1618, + "ATCACCG": 1619, + "CAGTAA": 1620, + "ATCGACA": 1621, + "CACGAGG": 1622, + "CGGCGTT": 1623, + "AAAGTG": 1624, + "CACGCGG": 1625, + "CCGCAGG": 1626, + "ACCTTGG": 1627, + "CTAAGG": 1628, + "CCGGAAG": 1629, + "CTGTAG": 1630, + "CCAGAAG": 1631, + "CCCGAAG": 1632, + "CTTGAAG": 1633, + "AGAAATT": 1634, + "CTGGTCA": 1635, + "ACATCC": 1636, + "TACCAGG": 1637, + "CTAACG": 1638, + "CCGGCGGCG": 1639, + "ACGGTGG": 1640, + "AACCG": 1641, + "ACCGCCA": 1642, + "CTCTGCG": 1643, + "TGCGGG": 1644, + "AGGCTT": 1645, + "AGAGTT": 1646, + "CCTCTCG": 1647, + "ATCGGTG": 1648, + "CCGCCGCCG": 1649, + "ACAGGCG": 1650, + "ATCCACG": 1651, + "TCGATCG": 1652, + "CTCACCG": 1653, + "TGAGTT": 1654, + "TCGACC": 1655, + "CTAGCA": 1656, + "CCAGCCA": 1657, + "ACGCTCG": 1658, + "CTCGCGCG": 1659, + "CACGAAG": 1660, + "TCTCGCG": 1661, + "CCCCCCG": 1662, + "CTTACA": 1663, + "CAGCGTG": 1664, + "ACCAGCA": 1665, + "CAAGCTG": 1666, + "CCCAGCA": 1667, + "ATGCGCG": 1668, + "TCCCGCG": 1669, + "ACTTAG": 1670, + "ATCGTGG": 1671, + "CTCCCCG": 1672, + "CTCGGAG": 1673, + "TACCCA": 1674, + "TATCAAA": 1675, + "ACCATCA": 1676, + "CCTGGGCG": 1677, + "CAGTAG": 1678, + "ATCACCA": 1679, + "TACGCA": 1680, + "CTTCACG": 1681, + "CCGGCGGG": 1682, + "CCGCGACG": 1683, + "ATCCCCG": 1684, + "CTATTTT": 1685, + "TGTGTG": 1686, + "ATCTCGG": 1687, + "ATTGAAG": 1688, + "CCTTAG": 1689, + "TATAATT": 1690, + "CTTCTGG": 1691, + "CCTCAAG": 1692, + "CTGATGG": 1693, + "TCCTTGG": 1694, + "TAATATT": 1695, + "TGCGCCG": 1696, + "CCGGATG": 1697, + "ACGGCCA": 1698, + "ACCTGCA": 1699, + "CTTCAAA": 1700, + "CCTTAA": 1701, + "CGGGACG": 1702, + "TAAATAA": 1703, + "ATTGATG": 1704, + "CATGCCG": 1705, + "CTCGTCA": 1706, + "CTTGTCG": 1707, + "TTGAAAA": 1708, + "CCAAAAA": 1709, + "TGATGG": 1710, + "CCCGGGCG": 1711, + "CCTCGAA": 1712, + "ACAACT": 1713, + "AGCGCCA": 1714, + "TCCTTCG": 1715, + "TGGTAG": 1716, + "CTTCAGG": 1717, + "CGGGGGG": 1718, + "TCCGCCA": 1719, + "CCAGGAA": 1720, + "CGGCGCTG": 1721, + "TAAACG": 1722, + "CCTTCGG": 1723, + "AAGAAGG": 1724, + "CAGCTGG": 1725, + "CCGATGG": 1726, + "ATATATT": 1727, + "ACCTTCA": 1728, + "CCTCTGG": 1729, + "CCAGTCG": 1730, + "CTTCATG": 1731, + "CAAAACA": 1732, + "CCCCTTG": 1733, + "TACGTG": 1734, + "CAGGTTG": 1735, + "TAACCA": 1736, + "AGCGACG": 1737, + "TACCGCG": 1738, + "TAACTT": 1739, + "CGCGTGG": 1740, + "ACTGTG": 1741, + "AGCGAGG": 1742, + "CTTGCGG": 1743, + "ATTTTAG": 1744, + "CTTCCGG": 1745, + "CGGGAAG": 1746, + "CAGCAAG": 1747, + "CTGTTCG": 1748, + "TCAAAAA": 1749, + "CTTCCCG": 1750, + "CTCTAA": 1751, + "TATTGAA": 1752, + "CCGCGTCG": 1753, + "TCCGCGG": 1754, + "CGGGGAG": 1755, + "TAGAAAA": 1756, + "ACGGCGCG": 1757, + "ATGGTCG": 1758, + "ACGCGCA": 1759, + "CCGTCT": 1760, + "CTGAAGG": 1761, + "CCGGGAA": 1762, + "TGGCCGG": 1763, + "CAGCATG": 1764, + "TCCATCG": 1765, + "CTGGGAG": 1766, + "AGCATCG": 1767, + "CTTATG": 1768, + "ATAAAAG": 1769, + "TAGGTT": 1770, + "ATTAAAA": 1771, + "ACGTAG": 1772, + "CCCTTCA": 1773, + "CTAGTT": 1774, + "CTCTTCA": 1775, + "CTTGTTG": 1776, + "TGGGCGG": 1777, + "ACACTG": 1778, + "CGGGATG": 1779, + "CGGGCGAG": 1780, + "CTCGCCGG": 1781, + "CCCCTCC": 1782, + "CTTGGGG": 1783, + "CGGCATCG": 1784, + "TTTTCTT": 1785, + "CTCCTCA": 1786, + "TCATCC": 1787, + "TGCGCGG": 1788, + "TTCGCGG": 1789, + "CTCCCAG": 1790, + "TCGCGAA": 1791, + "CCCACCA": 1792, + "CTCTTTT": 1793, + "CAAGCCG": 1794, + "CCTGAAG": 1795, + "CCTCGACG": 1796, + "ACCACCA": 1797, + "CAAAATG": 1798, + "TATTTCA": 1799, + "ATCAAAG": 1800, + "CAGGCTG": 1801, + "ATCATGG": 1802, + "CCAGTTG": 1803, + "CCCATCA": 1804, + "CCTCGTCG": 1805, + "TCTTGAA": 1806, + "TCCATCA": 1807, + "ACGGCGAG": 1808, + "ACGCTGG": 1809, + "ACCTCCG": 1810, + "CATGATG": 1811, + "CCGCACG": 1812, + "TGACCG": 1813, + "ATCCTTG": 1814, + "TCCTGCA": 1815, + "ACATAG": 1816, + "TTGGTGG": 1817, + "CCAGATG": 1818, + "CAGCCTG": 1819, + "ACCTAT": 1820, + "ACCCGCA": 1821, + "ATTGATT": 1822, + "AAAAAGG": 1823, + "CCCGTGG": 1824, + "AAGGTCG": 1825, + "CGGGCCA": 1826, + "ATCAACG": 1827, + "TCTTAG": 1828, + "ATTGTTG": 1829, + "TGTGTGTG": 1830, + "ATAATTTT": 1831, + "ACGGGGG": 1832, + "CCAGCTG": 1833, + "CTTGCTG": 1834, + "AGGGCGG": 1835, + "CATGAAG": 1836, + "TTGGCGG": 1837, + "AGGGGCG": 1838, + "TATGTG": 1839, + "TCCTCCG": 1840, + "CTCAACG": 1841, + "ATTTTCA": 1842, + "CACACACA": 1843, + "AGGCGCG": 1844, + "TTCTCG": 1845, + "ACCCCGG": 1846, + "TCCTGGG": 1847, + "AAGGCCG": 1848, + "TGTTAA": 1849, + "TGAGCG": 1850, + "CCCGCCGG": 1851, + "TACTAA": 1852, + "CAGGCCA": 1853, + "TTTTTGG": 1854, + "ACCTGAA": 1855, + "TCCTCCA": 1856, + "CTGGCAG": 1857, + "CTTGAGG": 1858, + "TTGCCGG": 1859, + "CCCCCTG": 1860, + "CTTTGCG": 1861, + "CCTAGG": 1862, + "ACGACCG": 1863, + "CAGGGGG": 1864, + "CTCTGGG": 1865, + "ATAGTG": 1866, + "ATGATGG": 1867, + "TATAGG": 1868, + "CCGACT": 1869, + "ACGATGG": 1870, + "CAAATCA": 1871, + "ACCTTTT": 1872, + "TCAGCAG": 1873, + "CGGGAGG": 1874, + "CCTTGGCG": 1875, + "CAAATTG": 1876, + "CCGGCTCG": 1877, + "TCGGTCA": 1878, + "TCCAGCA": 1879, + "CTCGGTG": 1880, + "AAGGGGG": 1881, + "TGGCGAA": 1882, + "ACACAG": 1883, + "CCTGATG": 1884, + "TCCGGCA": 1885, + "TGGCGCA": 1886, + "CTGGTTG": 1887, + "CCGCGTG": 1888, + "CTTTTGG": 1889, + "TCCTTCA": 1890, + "TCCGTCG": 1891, + "ACTGGGG": 1892, + "ACATTTT": 1893, + "ACGGCAG": 1894, + "CCGGCCAG": 1895, + "AGAAAAG": 1896, + "CAAGCAG": 1897, + "ATTTGAA": 1898, + "CTCCGAG": 1899, + "CTCAGCA": 1900, + "ATCGCGCG": 1901, + "TGTGTT": 1902, + "CGGGTTG": 1903, + "ATAAAAAA": 1904, + "TCCACCA": 1905, + "TACCGGG": 1906, + "ACTTGAA": 1907, + "CGGTCT": 1908, + "CCGCGTT": 1909, + "CGCGAGCG": 1910, + "TAGCTT": 1911, + "CCCTTGG": 1912, + "CCTGGAA": 1913, + "AAGGTGG": 1914, + "TCCTAA": 1915, + "TCTTTTG": 1916, + "CGGCGAAG": 1917, + "AAAATTTT": 1918, + "ATTACG": 1919, + "TCGGCAG": 1920, + "CCCAGGCG": 1921, + "TCAGCGG": 1922, + "ATGATCG": 1923, + "CTTTTCG": 1924, + "TCACTG": 1925, + "ATACCGG": 1926, + "CTATAT": 1927, + "TGTAA": 1928, + "CCTCGCCG": 1929, + "ACCTCTT": 1930, + "CCTCCGCG": 1931, + "TGTTAG": 1932, + "CGGCGGAG": 1933, + "TCTGGGG": 1934, + "CTGGGCA": 1935, + "TCGACGG": 1936, + "AGGGGGG": 1937, + "AATTTCA": 1938, + "ATGGAAG": 1939, + "CTGCTTG": 1940, + "CTCGAGCG": 1941, + "CCGCGCGG": 1942, + "TGGCGAG": 1943, + "TTCGCCA": 1944, + "ATCCAAA": 1945, + "AAGGAAG": 1946, + "CCGGTTG": 1947, + "AGTTAA": 1948, + "CTCCT": 1949, + "TCTTCTT": 1950, + "ACGCCCG": 1951, + "AACGTT": 1952, + "ATGGCCA": 1953, + "CCGGCACG": 1954, + "CTCAACA": 1955, + "TCCTGAA": 1956, + "CCAGCAGG": 1957, + "CATGTCG": 1958, + "CTCACCA": 1959, + "CTGGCGCG": 1960, + "AATGTG": 1961, + "AAGGAGG": 1962, + "ATTGCCG": 1963, + "CCTTCTT": 1964, + "TCCTTTT": 1965, + "CCCACCG": 1966, + "TCTCGAG": 1967, + "CCAGCTCG": 1968, + "ACCCGGG": 1969, + "CCGCGCTG": 1970, + "AAAATGG": 1971, + "AGCATCA": 1972, + "AATTTTG": 1973, + "CCTTCAG": 1974, + "CACGCCA": 1975, + "ACCGTCA": 1976, + "CCCTTTT": 1977, + "TACTAG": 1978, + "CTTACG": 1979, + "AATTTAA": 1980, + "ATTAAG": 1981, + "TTTTTAT": 1982, + "ATCTTGG": 1983, + "CGAGTT": 1984, + "CTTTATT": 1985, + "AAAATATT": 1986, + "CCGTTCG": 1987, + "CTCAGGG": 1988, + "AAATTAA": 1989, + "CCCAAGG": 1990, + "CTCGTTG": 1991, + "ACCTCCA": 1992, + "CTACCGG": 1993, + "ATCAATG": 1994, + "ACGGTCA": 1995, + "CGGCATG": 1996, + "CCCTAG": 1997, + "CAGGTCA": 1998, + "CGGTAA": 1999, + "CCCTAA": 2000, + "CCTTCCA": 2001, + "CCAGACG": 2002, + "TCTCCGG": 2003, + "CTCCGCCG": 2004, + "TCTACT": 2005, + "TTTGTTG": 2006, + "CTTTCCG": 2007, + "CAAGATG": 2008, + "CTCCGCA": 2009, + "TGGGGGG": 2010, + "AAAAATAA": 2011, + "CAAATCG": 2012, + "CTTTGAA": 2013, + "TCGGGCA": 2014, + "CCAGCACG": 2015, + "CCTGCCA": 2016, + "TCCCCGG": 2017, + "TACAGCG": 2018, + "CCGTCCG": 2019, + "TGAGTG": 2020, + "CTCATGG": 2021, + "ACCGTGG": 2022, + "ATTTTGG": 2023, + "AAGCGCG": 2024, + "CAGGCAG": 2025, + "ATGGAGG": 2026, + "CAAAAGG": 2027, + "TCCTCTT": 2028, + "TCATAG": 2029, + "CCTGACG": 2030, + "TACTTCG": 2031, + "CTCCGGCG": 2032, + "TCGCCCG": 2033, + "CCTTTTG": 2034, + "CCCTGCA": 2035, + "CCCGGTG": 2036, + "AAAGAAG": 2037, + "ACCAAGG": 2038, + "CAAATGG": 2039, + "CTGCCAG": 2040, + "CATTTTG": 2041, + "CAGCGAA": 2042, + "CCCCT": 2043, + "CCCATGG": 2044, + "AAGGCCA": 2045, + "AGTTAG": 2046, + "CGGCTTG": 2047, + "CGGGGGCG": 2048, + "ACAGCAG": 2049, + "CTGCGAG": 2050, + "AGAGTG": 2051, + "CTCGACC": 2052, + "ATCGGCGG": 2053, + "ATCCCAG": 2054, + "TAAAAAT": 2055, + "CTGACGG": 2056, + "TTTGATG": 2057, + "TTCCTG": 2058, + "CCGAGCA": 2059, + "CGGAGCG": 2060, + "TTTGAAG": 2061, + "CGCGTTG": 2062, + "CTAGGG": 2063, + "CTCAAAG": 2064, + "ACAACC": 2065, + "CCGTGCG": 2066, + "CTTTCTG": 2067, + "CCACGAA": 2068, + "CCCGGAA": 2069, + "TCGAGCA": 2070, + "ACATAT": 2071, + "CTACGCG": 2072, + "CAGAAAA": 2073, + "ACGTCGG": 2074, + "ATGGGGG": 2075, + "TTTGATT": 2076, + "CTTCGGCG": 2077, + "CTTGCCA": 2078, + "ACATCGG": 2079, + "CCGAAGG": 2080, + "TCATCGG": 2081, + "CCGAACG": 2082, + "TCTTGCG": 2083, + "AGGCCGG": 2084, + "CTTTTCA": 2085, + "CGCGATCG": 2086, + "CTTTCCA": 2087, + "TAGTTTT": 2088, + "TTCACG": 2089, + "ACCCTGG": 2090, + "ACGACT": 2091, + "ATCTCCA": 2092, + "CAGTTCG": 2093, + "ATAATTG": 2094, + "CCTGTCG": 2095, + "ATCATTG": 2096, + "CTGAGCG": 2097, + "ATCCGGCG": 2098, + "ACTAAG": 2099, + "TTCGGG": 2100, + "CCATCCG": 2101, + "CGCGCGAG": 2102, + "AATTATT": 2103, + "CTCCCC": 2104, + "ACTTTTG": 2105, + "ATGGTCA": 2106, + "CATGCTG": 2107, + "TAACTG": 2108, + "CCTGTTG": 2109, + "AAGGTCA": 2110, + "CCAGTGG": 2111, + "CTTAAG": 2112, + "CTTGACG": 2113, + "ATAATCA": 2114, + "TGACGG": 2115, + "CCGGCCCG": 2116, + "ATACAAA": 2117, + "AAATTCG": 2118, + "CCATCAG": 2119, + "CCAGGCA": 2120, + "TGCTAG": 2121, + "CCGAGGG": 2122, + "CGGACGG": 2123, + "TCTAAAA": 2124, + "CTTTTAA": 2125, + "CCTTTGG": 2126, + "CAGGGCA": 2127, + "CACGTTG": 2128, + "ACTAAAA": 2129, + "AGCGTGG": 2130, + "ATGTTTT": 2131, + "ATATTAA": 2132, + "CAAGACG": 2133, + "CCGACCA": 2134, + "ACCCAGG": 2135, + "AGGCGCA": 2136, + "CAAGCGG": 2137, + "TGGGTGG": 2138, + "CTGGCCGG": 2139, + "ACCGGAG": 2140, + "CCGTAA": 2141, + "ATATTCG": 2142, + "TCTTTCA": 2143, + "TACGTT": 2144, + "ACCTGCTG": 2145, + "ACTCGCG": 2146, + "CCATTTT": 2147, + "TTCAAGG": 2148, + "TTCGATG": 2149, + "CAGCAGCG": 2150, + "CCCTGGCG": 2151, + "CCCGACA": 2152, + "CCGCCGCA": 2153, + "TAAGTG": 2154, + "CGGTCC": 2155, + "CCATAT": 2156, + "ATATATAT": 2157, + "CCAGCCGG": 2158, + "TCCGACG": 2159, + "CCTTGAA": 2160, + "TCGTCC": 2161, + "CTTTCAG": 2162, + "ATTGCTG": 2163, + "TCGGCGGCG": 2164, + "TTGGGGG": 2165, + "CTACCAG": 2166, + "CCCGTCA": 2167, + "ATCCCCA": 2168, + "TCGATGG": 2169, + "TTCAACA": 2170, + "ATTGGGG": 2171, + "CGGCGGCGG": 2172, + "ACCGATG": 2173, + "ACCGAAG": 2174, + "TTCGTCA": 2175, + "TGCACG": 2176, + "CTCGCAG": 2177, + "TCTAAG": 2178, + "CATGACG": 2179, + "AAAATAG": 2180, + "CCCCTCA": 2181, + "ACCTTTG": 2182, + "AGCAAGG": 2183, + "CTCCCTG": 2184, + "ACCTGTT": 2185, + "CAGGTAG": 2186, + "CCCCAAG": 2187, + "CCGCGATG": 2188, + "TGAAGG": 2189, + "TGAAATT": 2190, + "ATAATAT": 2191, + "TCTCCAG": 2192, + "CGGCGTGG": 2193, + "ATAAATG": 2194, + "ACGCGAA": 2195, + "CCGCGCTCG": 2196, + "TCAGGGG": 2197, + "CCGCGAGG": 2198, + "CCACGAG": 2199, + "CCGCAAG": 2200, + "CTACTGG": 2201, + "CCTGCTGG": 2202, + "TTCAATT": 2203, + "TAACAG": 2204, + "TAAAAAG": 2205, + "ATCACGG": 2206, + "ATCCGAA": 2207, + "TCCGGAG": 2208, + "CCCGCGAG": 2209, + "ACCAACA": 2210, + "CTGAAAA": 2211, + "TTCCAG": 2212, + "TATTTAT": 2213, + "TCTCGGG": 2214, + "TAAAGAA": 2215, + "AAGATCG": 2216, + "TCCCGAG": 2217, + "CTTTCGG": 2218, + "CCACCCG": 2219, + "TAAACT": 2220, + "CCTCAGG": 2221, + "AAGCCGG": 2222, + "ATGAAGG": 2223, + "CCCAGAG": 2224, + "CCGGGTG": 2225, + "CAGGGAG": 2226, + "CGCGACA": 2227, + "ATGCTGG": 2228, + "TAATCT": 2229, + "AAGTTTT": 2230, + "TCGACCG": 2231, + "TCTGCTG": 2232, + "AACGCCG": 2233, + "ATACCAG": 2234, + "TACTGGG": 2235, + "CCGGATCG": 2236, + "ACCCTCG": 2237, + "ATTGCCA": 2238, + "AGGCGAA": 2239, + "CTTGGAG": 2240, + "ACTTTCA": 2241, + "TTGTTTT": 2242, + "CCATGCG": 2243, + "TGGCGGG": 2244, + "ACCACCG": 2245, + "TATACG": 2246, + "CGCGCCCG": 2247, + "CAGCGCCG": 2248, + "ACAAGAA": 2249, + "TCCCGGG": 2250, + "ACACTT": 2251, + "CCAGGTG": 2252, + "CTCGACGG": 2253, + "TCTTTTTT": 2254, + "CACATCG": 2255, + "ATCGCTG": 2256, + "TTGCGCG": 2257, + "CTCTTGG": 2258, + "TTGGCCG": 2259, + "CGGATGG": 2260, + "CAGATGG": 2261, + "TATTGTT": 2262, + "TTCGTGG": 2263, + "TCCCGCA": 2264, + "CCTACGG": 2265, + "TCGCTT": 2266, + "TCGGCCAG": 2267, + "ACCATGG": 2268, + "AAAAAAAT": 2269, + "ATCTGCA": 2270, + "CTGCTCA": 2271, + "TCTCCTG": 2272, + "CATGTTG": 2273, + "CTCTCGG": 2274, + "CCGGCTT": 2275, + "TCCGAGG": 2276, + "CTTCGAA": 2277, + "CTCCAAG": 2278, + "TCCAGAA": 2279, + "CCTTCGCG": 2280, + "ACCTGCT": 2281, + "TTCATGG": 2282, + "CTGAACG": 2283, + "ATGTAT": 2284, + "AACATCA": 2285, + "TCAGGAG": 2286, + "ACCTAG": 2287, + "CAGCAAA": 2288, + "ACGGGCA": 2289, + "AGAGAGAG": 2290, + "TCTTGAG": 2291, + "TCTTCCA": 2292, + "CGGGCCGG": 2293, + "CTCGACCG": 2294, + "CAGCGGCG": 2295, + "TCGGCTG": 2296, + "CCCCAAA": 2297, + "CCCACGG": 2298, + "TGATGAA": 2299, + "ATTTCCA": 2300, + "ACTGGAG": 2301, + "CCCAGAA": 2302, + "TGCTGCA": 2303, + "TTGGTCG": 2304, + "CCGAGCGCG": 2305, + "TTGGCCA": 2306, + "CTCGATCG": 2307, + "ATAAACA": 2308, + "CACGCAG": 2309, + "TTTTGAA": 2310, + "ACCCGAG": 2311, + "CTATTGG": 2312, + "CATCAAG": 2313, + "AAAATCG": 2314, + "TTCTGG": 2315, + "TCAACT": 2316, + "AGCACCA": 2317, + "CCGGCAAG": 2318, + "CCTGGCA": 2319, + "ACCAGAA": 2320, + "ACAGGGG": 2321, + "TCTGGAG": 2322, + "TGCGCCA": 2323, + "TCCCAGG": 2324, + "TCTTCGG": 2325, + "TTCGACA": 2326, + "CTTGCAG": 2327, + "CTTCATT": 2328, + "TTCCCG": 2329, + "CTCTTTG": 2330, + "AGCACGG": 2331, + "CCCAACG": 2332, + "ATCGGAG": 2333, + "CCGGCTGG": 2334, + "ATATTCA": 2335, + "ATCGTTG": 2336, + "CAAGTTG": 2337, + "ACCGACA": 2338, + "ATGGATG": 2339, + "AAGAAAG": 2340, + "TACTTTT": 2341, + "ATGGATT": 2342, + "TCAGGAA": 2343, + "CACGTGG": 2344, + "AAAAAGAA": 2345, + "ACTCGAG": 2346, + "TCGGAGG": 2347, + "TCTTTGG": 2348, + "TCTTTAA": 2349, + "CCAGAGG": 2350, + "TCGCTCG": 2351, + "TTGGTCA": 2352, + "ATCCGAG": 2353, + "ACAGCGG": 2354, + "TCGTCT": 2355, + "CCAAGCG": 2356, + "CCGCCTCG": 2357, + "CCCCGCA": 2358, + "ACGGCAAG": 2359, + "CTCCATG": 2360, + "CAAAACG": 2361, + "TCGCGGG": 2362, + "TTTCAAA": 2363, + "TGCCGCA": 2364, + "AAATTCA": 2365, + "AGCATGG": 2366, + "ATGGACG": 2367, + "CCGCCGAA": 2368, + "CCGCCCA": 2369, + "CTGCCTG": 2370, + "ACTGGAA": 2371, + "TTCTTG": 2372, + "CTGCGAA": 2373, + "TGTTCG": 2374, + "CCACGCA": 2375, + "CAGAAGG": 2376, + "TTCCGG": 2377, + "AAAAACT": 2378, + "CTGTCGG": 2379, + "AGGGCGAG": 2380, + "ATGCTCG": 2381, + "ATGAGCG": 2382, + "TCGCTGG": 2383, + "ATATGAA": 2384, + "CCCGCTCG": 2385, + "TAACGG": 2386, + "TCAGCCA": 2387, + "CCGGCCTG": 2388, + "TCCTTTG": 2389, + "TCGGGAG": 2390, + "TGACC": 2391, + "CCGATCA": 2392, + "AAGTAT": 2393, + "ATATTGG": 2394, + "TGCCGAA": 2395, + "ATGACGG": 2396, + "CTCGGCGG": 2397, + "CATTTCA": 2398, + "ATTCAAA": 2399, + "ATGACC": 2400, + "CTCTCTCT": 2401, + "CCCGTTG": 2402, + "CGGGTCA": 2403, + "CGGCGCAG": 2404, + "ATGGCAG": 2405, + "ACAGGAG": 2406, + "TGATGAG": 2407, + "CGCGCTGG": 2408, + "CAAGCCA": 2409, + "ACAAATT": 2410, + "ACCACGG": 2411, + "TCGAGGG": 2412, + "CCCCATG": 2413, + "CTCTGCA": 2414, + "AGGTCGG": 2415, + "ACCAAAG": 2416, + "CGCGTCA": 2417, + "CTCGGGCG": 2418, + "ACCTGAT": 2419, + "CCGCCGGG": 2420, + "ATCGATT": 2421, + "TCTCGAA": 2422, + "CCTTCTG": 2423, + "ATCCCC": 2424, + "CAAACCA": 2425, + "CTCCAAA": 2426, + "TATGGCG": 2427, + "TTGGAAG": 2428, + "CAGTAT": 2429, + "CTATATT": 2430, + "TCTGGAA": 2431, + "CCCTGAG": 2432, + "AGCAACA": 2433, + "CCCGGCGG": 2434, + "TCGAAGG": 2435, + "ATGGGCA": 2436, + "TTCACCA": 2437, + "TTGCTGG": 2438, + "ATGAATT": 2439, + "AGGAGCG": 2440, + "CGGGCGGG": 2441, + "ATAGGCG": 2442, + "TCCATGG": 2443, + "ACTTCTT": 2444, + "ATTGCGG": 2445, + "CGGGGCA": 2446, + "ATGTCGG": 2447, + "TTTTCCA": 2448, + "ACGAAGG": 2449, + "TTTTTCT": 2450, + "TCCGCTG": 2451, + "ACCGGAA": 2452, + "AGCACCG": 2453, + "CCCAAAG": 2454, + "ATCCGCCG": 2455, + "TAACCG": 2456, + "TTGATCG": 2457, + "CATGCGG": 2458, + "ACAAAAG": 2459, + "AGGTCT": 2460, + "AAAAAAAG": 2461, + "CCTCCTG": 2462, + "CAAGATT": 2463, + "CCACCTG": 2464, + "TACTGCG": 2465, + "TATCATT": 2466, + "CTATCTG": 2467, + "ACTTGCG": 2468, + "CCAGCCCG": 2469, + "ATTGCAG": 2470, + "ACTCAAA": 2471, + "ACCAGGCG": 2472, + "ATTGGAA": 2473, + "ACCGCTG": 2474, + "AAGCGAA": 2475, + "ACTTTGG": 2476, + "ATTTTTAA": 2477, + "TATATAA": 2478, + "TATTTGG": 2479, + "CCTTTCA": 2480, + "CCGCTTG": 2481, + "ATTGAGG": 2482, + "CTTTGGG": 2483, + "ACGCGGG": 2484, + "AGCGTCA": 2485, + "CATGCAG": 2486, + "ATCAGAA": 2487, + "CCTCCAGG": 2488, + "ATACTGG": 2489, + "TTGGAGG": 2490, + "TCCCTGG": 2491, + "CACGCCGG": 2492, + "AAGAATT": 2493, + "TTGGTTG": 2494, + "CTACGAG": 2495, + "ACCGCGAG": 2496, + "ATCCAAG": 2497, + "CCAGCGCA": 2498, + "ACAGGAA": 2499, + "ACCCGAA": 2500, + "CCTTTCG": 2501, + "CTCAATG": 2502, + "CCCCGAA": 2503, + "AAGCTCG": 2504, + "ACGGGAG": 2505, + "CTCACGG": 2506, + "TGATCGG": 2507, + "TTTTTTTG": 2508, + "AGCAATT": 2509, + "TCTTGTT": 2510, + "ATTGGAG": 2511, + "AAAACCA": 2512, + "CGGCGCCGG": 2513, + "ATTCGAA": 2514, + "CTCATTG": 2515, + "ATAAGAA": 2516, + "AGAAACA": 2517, + "ACTGCTG": 2518, + "TTCATG": 2519, + "ACTCCGG": 2520, + "CCTGTGG": 2521, + "ACCCAAA": 2522, + "ACGTCC": 2523, + "CTGCGTG": 2524, + "CCTCGGGG": 2525, + "TTCAAAG": 2526, + "CAAGTCG": 2527, + "ACCGGGCG": 2528, + "ATCATCT": 2529, + "AGCAAAG": 2530, + "AGCGAAG": 2531, + "ATGACCG": 2532, + "CAGGACA": 2533, + "ACCAGAG": 2534, + "TCACCGG": 2535, + "CCCTTTG": 2536, + "CTCTCCA": 2537, + "CCGGGCGG": 2538, + "CTGTAT": 2539, + "ATTTCGG": 2540, + "CGGGATCG": 2541, + "AGGGTGG": 2542, + "TCGGGAA": 2543, + "CGGGCTCG": 2544, + "ATTTTTTG": 2545, + "ATTTCAG": 2546, + "ATGGGAG": 2547, + "CCGCGCAG": 2548, + "TCGTAA": 2549, + "ACCAACG": 2550, + "CCCTCCA": 2551, + "CTCCCCA": 2552, + "CAAGTGG": 2553, + "TCCAGAG": 2554, + "CCGGCGAA": 2555, + "CAAGAGG": 2556, + "TTCAACG": 2557, + "TACATCA": 2558, + "ACTACC": 2559, + "CCCGCCCG": 2560, + "ATGGCTG": 2561, + "ACGGCTG": 2562, + "CGCGCGCA": 2563, + "CCTACCG": 2564, + "TTCAGG": 2565, + "ATTGTAA": 2566, + "CCTCGCA": 2567, + "TTGGATT": 2568, + "CGGCGAGCG": 2569, + "CCTCCTCG": 2570, + "TCAGCCG": 2571, + "ACGGAGG": 2572, + "AAGGACG": 2573, + "CCTAAAA": 2574, + "TGCGTCG": 2575, + "AGCAACG": 2576, + "TGGTCGG": 2577, + "CCTCTTCG": 2578, + "TCCGCAG": 2579, + "CCGAGCAG": 2580, + "CACGACA": 2581, + "ATTGTCA": 2582, + "AGAAATG": 2583, + "TTCACCG": 2584, + "ACCAATT": 2585, + "ACGGACG": 2586, + "CTTCGCA": 2587, + "TTTGCCA": 2588, + "CTTTGAG": 2589, + "ATAATATT": 2590, + "AAGCTGG": 2591, + "CCTATCG": 2592, + "CCTGGTG": 2593, + "ATCGAGCG": 2594, + "TCGAGCAG": 2595, + "CCGGACA": 2596, + "TTTTTCG": 2597, + "CCCTGAA": 2598, + "ACCGCAG": 2599, + "TCCACCG": 2600, + "AACGCGG": 2601, + "TTTAG": 2602, + "ACTACTT": 2603, + "AACAACA": 2604, + "AACGTCG": 2605, + "CCCAACA": 2606, + "ATCAAAAA": 2607, + "CTAAATT": 2608, + "CCGCATCG": 2609, + "CAGGATT": 2610, + "CGGCGCCA": 2611, + "CCCATTG": 2612, + "TTTTTATT": 2613, + "ATTGTCG": 2614, + "TCTTCAG": 2615, + "CAGGCGCG": 2616, + "AAGGGCA": 2617, + "TTTTTAG": 2618, + "ATGAAAG": 2619, + "ATCTCCG": 2620, + "AAATAAAA": 2621, + "CTTGGCA": 2622, + "ACCTCGCG": 2623, + "TCAGCGCG": 2624, + "ACTTCGG": 2625, + "ACTTTAA": 2626, + "TGGGCCG": 2627, + "CTCCGTG": 2628, + "CTCCAGCG": 2629, + "CTGTCC": 2630, + "AGAAAGG": 2631, + "TCTCGGCG": 2632, + "ATGGTTG": 2633, + "CTTGATT": 2634, + "TCCGCGAG": 2635, + "AAGGATT": 2636, + "ATCGCCGG": 2637, + "AACATCG": 2638, + "ACTCGAA": 2639, + "CCAGCTT": 2640, + "TCACAG": 2641, + "ATTGACG": 2642, + "AGCGCAG": 2643, + "TTACA": 2644, + "ACCATTG": 2645, + "TACAGGG": 2646, + "CCGGCGCA": 2647, + "TTCATTG": 2648, + "TGGCTGG": 2649, + "TTACG": 2650, + "TTCGAAG": 2651, + "TTATG": 2652, + "ACGGCGGCG": 2653, + "TGCGACG": 2654, + "CCTGCCGG": 2655, + "TTTGCCG": 2656, + "ATCATAA": 2657, + "CCTTCCG": 2658, + "TTTCCG": 2659, + "ACTCCAG": 2660, + "ATAAAGG": 2661, + "TGGTCT": 2662, + "TTAATAA": 2663, + "TGCGCTG": 2664, + "CCGCGCCA": 2665, + "CCGGCGCCG": 2666, + "CGGGGAA": 2667, + "ATCGCAG": 2668, + "TCCGGAA": 2669, + "CCGCGAAG": 2670, + "CCGGGTCG": 2671, + "AGCGATG": 2672, + "CCTCGAGG": 2673, + "ATGCGAA": 2674, + "AAAACTT": 2675, + "ATTTTATT": 2676, + "TGCGCAG": 2677, + "CTTTTAG": 2678, + "TTTGTAA": 2679, + "TCGGCGGG": 2680, + "CGGCAAGG": 2681, + "TCCTAT": 2682, + "CTGGATT": 2683, + "CCGCGCCGG": 2684, + "TCACGAA": 2685, + "TTCAAG": 2686, + "AAAAACG": 2687, + "TCTTGGG": 2688, + "AACGACG": 2689, + "CTGGACA": 2690, + "TCGAGCGCG": 2691, + "CTCTACG": 2692, + "ATACAGG": 2693, + "TGCTTG": 2694, + "AAATCCA": 2695, + "TCTCCTT": 2696, + "CCTCAAA": 2697, + "CAAATAT": 2698, + "TTTGCTG": 2699, + "CCTACTT": 2700, + "TGCTGAA": 2701, + "TCCTGTT": 2702, + "CCTCCCA": 2703, + "CGCGCACG": 2704, + "CCTGATCG": 2705, + "CAGCGCGG": 2706, + "CCAGCGAG": 2707, + "TCGGACG": 2708, + "AGCGCTG": 2709, + "ACTTGTT": 2710, + "CTCTCCG": 2711, + "AACAATT": 2712, + "TCATTTT": 2713, + "CTACCTG": 2714, + "TGGGAGG": 2715, + "ACAGCCA": 2716, + "CCGGATT": 2717, + "TATTTATT": 2718, + "TACGACG": 2719, + "TCCAGGCG": 2720, + "ACTAGG": 2721, + "CTTGTGG": 2722, + "CTTTGTT": 2723, + "TCGCGCCG": 2724, + "CTTCTTCG": 2725, + "CAGACC": 2726, + "ATCCCTG": 2727, + "CTCGTAG": 2728, + "TTGATGG": 2729, + "CTTCCTT": 2730, + "CTGACCA": 2731, + "CTCGTCGG": 2732, + "ATGCGCA": 2733, + "ATAATAG": 2734, + "CTCAATT": 2735, + "TCCGTCA": 2736, + "ATGCCCG": 2737, + "ATAGAAG": 2738, + "ATGGGAA": 2739, + "TCTCAAA": 2740, + "CACATCA": 2741, + "TAATGAA": 2742, + "ACGGGAA": 2743, + "TCTGCGG": 2744, + "ACAGAAG": 2745, + "TTTCAAG": 2746, + "TGGGCAG": 2747, + "TCCGTGG": 2748, + "CGGCGTTG": 2749, + "ATCTGAA": 2750, + "ATCCATG": 2751, + "TCTTCTG": 2752, + "TGTCGG": 2753, + "TCCATTG": 2754, + "ATACGCG": 2755, + "TACGCCG": 2756, + "CCACGCCG": 2757, + "CTTTGCA": 2758, + "CTCGATT": 2759, + "CTCGCCCG": 2760, + "TATCGAG": 2761, + "AAGGACA": 2762, + "AAATTAG": 2763, + "CCTGCCCG": 2764, + "AAATTGG": 2765, + "CTTAAAA": 2766, + "ACTTCCA": 2767, + "CGGACCG": 2768, + "AAAGATT": 2769, + "CGGGCGGCG": 2770, + "TCTTGCCG": 2771, + "CTGCATG": 2772, + "CCGGGCCG": 2773, + "CAGACCG": 2774, + "TCCGGGCG": 2775, + "CCGGCAGG": 2776, + "TAAAATG": 2777, + "AACGCCA": 2778, + "AGAATTG": 2779, + "TGGGCCA": 2780, + "ATGTCC": 2781, + "ATGGACA": 2782, + "CTGGGGCG": 2783, + "ACTTGAG": 2784, + "AAGGGAG": 2785, + "AGAATCA": 2786, + "ACGATCA": 2787, + "ACTTTTTT": 2788, + "CTGGTAG": 2789, + "CTGGGAA": 2790, + "ATGCAGG": 2791, + "TACCTGG": 2792, + "ATTGTGG": 2793, + "CTGGGTG": 2794, + "CTATCAG": 2795, + "TGCTGAG": 2796, + "TCCAAGG": 2797, + "CGGGCACG": 2798, + "CATTATT": 2799, + "AGAATGG": 2800, + "CGGTTCG": 2801, + "CTGCAAG": 2802, + "ATCGGAA": 2803, + "TCTGCCA": 2804, + "ATGTCT": 2805, + "CGGCAGCG": 2806, + "ATCTATT": 2807, + "CGCGACCG": 2808, + "CTTCGTG": 2809, + "CCGAGTT": 2810, + "TCCGAAG": 2811, + "ATATTTG": 2812, + "TGGGTCG": 2813, + "ATCCCTT": 2814, + "CCGGGTT": 2815, + "ACGGAAG": 2816, + "CTGATCA": 2817, + "AGGGCCG": 2818, + "AAAAAATG": 2819, + "CCAGGTCG": 2820, + "TCTCCCG": 2821, + "ACTCCTG": 2822, + "TAGTAT": 2823, + "CCCGGCCG": 2824, + "CTTTGTG": 2825, + "CACGTCA": 2826, + "CCAGATCG": 2827, + "ACTGAAG": 2828, + "CGCGCAGG": 2829, + "ACCTGAG": 2830, + "ACCTCAG": 2831, + "CGGTGACG": 2832, + "CCCTCCG": 2833, + "CAAACAG": 2834, + "TCTGCAG": 2835, + "CGGCGCTGG": 2836, + "CTATCTT": 2837, + "AGGCGAG": 2838, + "ATGCGGG": 2839, + "ATCCTCC": 2840, + "ATTGAAAA": 2841, + "ATGACT": 2842, + "CCTCTTG": 2843, + "TGGGAAG": 2844, + "ATGAACG": 2845, + "CTGAAAG": 2846, + "TCCTAG": 2847, + "ACGTAA": 2848, + "CTACAAG": 2849, + "CTACTCG": 2850, + "ATAATGG": 2851, + "TCTGTTG": 2852, + "AGGCGGG": 2853, + "CTTCCTCG": 2854, + "CTGCAAA": 2855, + "TCTGCCG": 2856, + "CCAACGG": 2857, + "TCCACGG": 2858, + "CTGTTTT": 2859, + "CGGCGCTCG": 2860, + "TCGCGAG": 2861, + "CGCGACGG": 2862, + "TATACT": 2863, + "TCCCGAA": 2864, + "CCTTCGAG": 2865, + "TCCAAAG": 2866, + "TCCAACA": 2867, + "TTTTGAG": 2868, + "ACCCACG": 2869, + "CCAGATT": 2870, + "AAATACA": 2871, + "TGGGGAG": 2872, + "TTTCTT": 2873, + "AGAATAA": 2874, + "TCTTGCA": 2875, + "AGGAAGG": 2876, + "AAGGGAA": 2877, + "TACCACG": 2878, + "CTTGTAG": 2879, + "CATTTCG": 2880, + "ATACATT": 2881, + "TGCCAG": 2882, + "CAGAAAG": 2883, + "TACAACA": 2884, + "CAAATAG": 2885, + "AATGAAG": 2886, + "ATATGGG": 2887, + "TGTTTTG": 2888, + "CGGCGGCA": 2889, + "TCCTGCT": 2890, + "ATCTCTT": 2891, + "TCTAGG": 2892, + "TGGGACG": 2893, + "CGCGCGGG": 2894, + "TACGGGG": 2895, + "CCTGGCCG": 2896, + "CGGCGATCG": 2897, + "TTCGATT": 2898, + "TTGGCAG": 2899, + "ACTCGGG": 2900, + "TCGGGGCG": 2901, + "CATGTGG": 2902, + "CTACCCG": 2903, + "CATTTGG": 2904, + "CTTCGTCG": 2905, + "CTAATAA": 2906, + "AGCGACA": 2907, + "TCCAATT": 2908, + "CCTTGCA": 2909, + "TCGGCCGG": 2910, + "TGAAAAG": 2911, + "ACAGCCG": 2912, + "CCGAGCGG": 2913, + "AGGAAAA": 2914, + "CTGCGCCG": 2915, + "CTACGGG": 2916, + "TTGCGAA": 2917, + "TCCCAAA": 2918, + "TCCCTCG": 2919, + "ATTGGCA": 2920, + "ATAGATT": 2921, + "ACGGCACG": 2922, + "CTTACT": 2923, + "CCGGCCGCG": 2924, + "CCCCAGCG": 2925, + "CTCGGAA": 2926, + "ACCTGCCG": 2927, + "CCAGCCAG": 2928, + "CATCGAA": 2929, + "AAGGTTG": 2930, + "CAGCACA": 2931, + "ACCCCCG": 2932, + "CATGCCA": 2933, + "TTTTTCTT": 2934, + "CCTCGATG": 2935, + "ACCTGGCG": 2936, + "TTGGCTG": 2937, + "TCAGAAG": 2938, + "CTTGGAA": 2939, + "CATCAAA": 2940, + "TTTGTCA": 2941, + "CCGGTGCG": 2942, + "ATACTCG": 2943, + "AACACCA": 2944, + "ACGAACG": 2945, + "ACCGCGCG": 2946, + "AGGATCG": 2947, + "AAGGATG": 2948, + "CGGCGACA": 2949, + "ACCTACA": 2950, + "ATATGTT": 2951, + "TTGGTAA": 2952, + "CCTGGTCG": 2953, + "TTGGGAG": 2954, + "CCTCGCGG": 2955, + "TCTGAAG": 2956, + "ATTGACA": 2957, + "CATTTAA": 2958, + "TCCGATG": 2959, + "TGGGCGAG": 2960, + "TATCGCG": 2961, + "AGGGGAG": 2962, + "ATATCCA": 2963, + "CCAGCGGG": 2964, + "TCCGCGCG": 2965, + "ACCTACG": 2966, + "AAGGCAG": 2967, + "TTGGATG": 2968, + "ATTTTTCA": 2969, + "CGGCAACG": 2970, + "CCCTCGCG": 2971, + "CTTCGCCG": 2972, + "ATCCT": 2973, + "ATCTACA": 2974, + "TCCTCAG": 2975, + "CGGAACG": 2976, + "TTCAATG": 2977, + "CGGTGCCG": 2978, + "CCTGCACG": 2979, + "CAAGACA": 2980, + "CTCCGAA": 2981, + "TCGATCA": 2982, + "TTTCGG": 2983, + "CCGAGCTG": 2984, + "AAATTTG": 2985, + "CTACACG": 2986, + "AGGGAGG": 2987, + "ACCAATG": 2988, + "CCTGCAGG": 2989, + "CACAACA": 2990, + "TCTTGTG": 2991, + "ACCCGGCG": 2992, + "TTCGTTG": 2993, + "CAGGGAA": 2994, + "CTTCGACG": 2995, + "CAGCGTCG": 2996, + "TCCTCTG": 2997, + "CATGAGG": 2998, + "CGCATCG": 2999, + "TCCTGAG": 3000, + "ACTGTTG": 3001, + "TCCGACA": 3002, + "CAGAGCG": 3003, + "TGCATCA": 3004, + "ATCCCGCG": 3005, + "TGCGTGG": 3006, + "TGCATCG": 3007, + "CCGGTAG": 3008, + "ATCCGTG": 3009, + "ATCAACT": 3010, + "TCCTGAT": 3011, + "CGGGCTGG": 3012, + "CCCGAGCG": 3013, + "CCAGGCCG": 3014, + "CCTCCACG": 3015, + "TAATTAA": 3016, + "ATAAATAA": 3017, + "CTGTCT": 3018, + "CACGATCG": 3019, + "CCGCGATCG": 3020, + "TGCTTGG": 3021, + "ACCGTTG": 3022, + "CACAG": 3023, + "TTTGCAG": 3024, + "CGGTGAG": 3025, + "AGGCGCTG": 3026, + "AGTTTTG": 3027, + "TCGCGTT": 3028, + "TATAAAG": 3029, + "CGGTCAG": 3030, + "AAATCTT": 3031, + "AATGATG": 3032, + "CCTGATT": 3033, + "ACTGCCG": 3034, + "TATCAAG": 3035, + "CCATCCA": 3036, + "ATAAGTT": 3037, + "CTGACT": 3038, + "ATCAGAG": 3039, + "CGGCATCA": 3040, + "TACGTCG": 3041, + "CAGGGTG": 3042, + "TGGGTCA": 3043, + "CGGGGTG": 3044, + "CTTGTCA": 3045, + "AAAATCT": 3046, + "ATTAATT": 3047, + "ATATTAG": 3048, + "CTACAAA": 3049, + "CCGAGCCG": 3050, + "TATATTG": 3051, + "TATTTCT": 3052, + "CAGGCCGG": 3053, + "AGGACGG": 3054, + "CCGCGCTGG": 3055, + "TTTGTGG": 3056, + "ACTGCCA": 3057, + "AGGCGTT": 3058, + "TCGAACG": 3059, + "TCGGCTT": 3060, + "CGGCGTCA": 3061, + "CGGCGACGG": 3062, + "CCGCCGCCA": 3063, + "ACCTGTG": 3064, + "CCAGTAG": 3065, + "TGGCGTT": 3066, + "TTTTCAG": 3067, + "AGCATTG": 3068, + "ACGAGGG": 3069, + "CACGCTCG": 3070, + "ATCGCGAG": 3071, + "ACTGCGG": 3072, + "TGCGAGG": 3073, + "CAGCGCCA": 3074, + "ACTGGCA": 3075, + "TCAGTTG": 3076, + "ACCTCTG": 3077, + "CCTGAGG": 3078, + "TGGCGATG": 3079, + "CCTCGTG": 3080, + "CAGAACG": 3081, + "CTGTTGG": 3082, + "TAAAACA": 3083, + "TAATTTG": 3084, + "TCTTTCG": 3085, + "CCGGCGTG": 3086, + "CTCTACA": 3087, + "ATTTTCG": 3088, + "CTATCGG": 3089, + "TGGGTTG": 3090, + "TGCTCGCG": 3091, + "CCGCCGACG": 3092, + "CCGCCGTCG": 3093, + "ATTCGCG": 3094, + "CCTCCGGG": 3095, + "CGGTCCG": 3096, + "TCGGCCTG": 3097, + "TATTCCA": 3098, + "CCGCGCCCG": 3099, + "CTTAGG": 3100, + "TTTTTTAA": 3101, + "TTTTGG": 3102, + "AAAAAAATT": 3103, + "TATTGCA": 3104, + "TCCCACG": 3105, + "TTGGGCA": 3106, + "CCGGCGACG": 3107, + "TAGCCGG": 3108, + "TATTTTTG": 3109, + "CTTGCCGG": 3110, + "TAGAATT": 3111, + "TACAATT": 3112, + "AAGCGCA": 3113, + "TGATCGCG": 3114, + "TATCTGG": 3115, + "AAGATGG": 3116, + "CCTACAG": 3117, + "CGAGCGCG": 3118, + "TCGCGCTG": 3119, + "CCTTCTCG": 3120, + "ACTCAAG": 3121, + "ACTTGCA": 3122, + "TGGATCG": 3123, + "CCACGTCG": 3124, + "AGCAATG": 3125, + "ATATCTT": 3126, + "TACATCG": 3127, + "CGAGTG": 3128, + "AAGAACG": 3129, + "TGGGCGCG": 3130, + "ACATCTT": 3131, + "ATACAAG": 3132, + "AACAAGG": 3133, + "TGATATT": 3134, + "ACACCGG": 3135, + "ACCCATG": 3136, + "TGGCGACG": 3137, + "CGGCCTCG": 3138, + "TCGGCAAG": 3139, + "CTGTTTG": 3140, + "TCGCGACG": 3141, + "TTGGGAA": 3142, + "CCCAATG": 3143, + "CCTGCTT": 3144, + "TTGAGCG": 3145, + "ATACCCG": 3146, + "TTTTGTT": 3147, + "TCCTGCTG": 3148, + "ACTTCAG": 3149, + "CTGTCCG": 3150, + "CCCGACGG": 3151, + "AAATATG": 3152, + "ATTGCTT": 3153, + "CCAAGGG": 3154, + "CTCGGCCG": 3155, + "CACAAGG": 3156, + "TAGAGCG": 3157, + "TCTCTTG": 3158, + "TAGGGCG": 3159, + "CCTGCGCA": 3160, + "TATCTTG": 3161, + "CTAGTG": 3162, + "TAAAAATT": 3163, + "ACCCAAG": 3164, + "CCAAAAG": 3165, + "ACGGCTT": 3166, + "CCTATGG": 3167, + "ATTTCCG": 3168, + "CCATCTT": 3169, + "CTAAAAG": 3170, + "CAGCTCA": 3171, + "TTTGAGG": 3172, + "TTGAAGG": 3173, + "TGGTGCG": 3174, + "CTATTAA": 3175, + "CGGGCAGG": 3176, + "CCCCCCCC": 3177, + "CCCGCCAG": 3178, + "CGGTGGG": 3179, + "CCCGGTCG": 3180, + "CCATCTG": 3181, + "ACGACCA": 3182, + "TACTTCA": 3183, + "ACTTGGG": 3184, + "ATAGATG": 3185, + "ACGTCT": 3186, + "CCTCCTT": 3187, + "TTTGTCG": 3188, + "ATCCACA": 3189, + "CCATGAA": 3190, + "AGAGAAG": 3191, + "AAAACAG": 3192, + "ATTTGTT": 3193, + "CCAACCG": 3194, + "ATCTCGCG": 3195, + "TGGCGTG": 3196, + "TTGCTCG": 3197, + "CGGCACCG": 3198, + "TAATCTT": 3199, + "TGGGGCA": 3200, + "TCGCGCAG": 3201, + "TCGCGCTCG": 3202, + "CTATTCG": 3203, + "TCTGGCA": 3204, + "CCTACCA": 3205, + "TATTCTT": 3206, + "AGGAGGG": 3207, + "AGAATCG": 3208, + "TCCCCCG": 3209, + "AAGAGCG": 3210, + "CCAGTCA": 3211, + "ACAAATG": 3212, + "CTGTGCG": 3213, + "ACTGATG": 3214, + "ATAGTTG": 3215, + "CGGCCGGG": 3216, + "CTCCCGCG": 3217, + "TGCTCA": 3218, + "CTCCTCGG": 3219, + "ACCCTTG": 3220, + "CCACGACG": 3221, + "ATTACT": 3222, + "TTTCTG": 3223, + "TCTCAAG": 3224, + "CTCGCGCA": 3225, + "CGGCAAA": 3226, + "AACAAAG": 3227, + "ACACGAA": 3228, + "CTGATTG": 3229, + "TCCCATG": 3230, + "AGAAACG": 3231, + "AATTTGG": 3232, + "TCGGCTCG": 3233, + "CTGCCCA": 3234, + "CACAAAG": 3235, + "CGGCGCGGG": 3236, + "ATGGCTT": 3237, + "CCCTCGAG": 3238, + "ATACGGG": 3239, + "CGGTGAA": 3240, + "AGTTTCA": 3241, + "ACTGCAG": 3242, + "AGGGCAG": 3243, + "TACCAAA": 3244, + "TATTTAG": 3245, + "TTTCCA": 3246, + "CTGCTCGG": 3247, + "CCCGCTGG": 3248, + "ATTTCTG": 3249, + "ACAGTTG": 3250, + "CCCGCCGCG": 3251, + "GGGAG": 3252, + "CCGCCTT": 3253, + "ATATGCG": 3254, + "ACAACTT": 3255, + "TCGGCGAA": 3256, + "CGGAAGG": 3257, + "CCCGCTT": 3258, + "ATGGCGCG": 3259, + "TATTTCG": 3260, + "TACGAGG": 3261, + "TGGGATG": 3262, + "CGGACC": 3263, + "TCGGCACG": 3264, + "TGATTGG": 3265, + "ACGGTTG": 3266, + "TAAACTT": 3267, + "CTACAGG": 3268, + "TATGGGG": 3269, + "CCTTTTTT": 3270, + "AC": 3271, + "ACAGATG": 3272, + "CACATGG": 3273, + "AACGAGG": 3274, + "CTATCCG": 3275, + "CCATTCG": 3276, + "CCGGCGTCG": 3277, + "ATCGGGCG": 3278, + "TCACTT": 3279, + "TCTACTT": 3280, + "ATCTGAG": 3281, + "CGGTGGCG": 3282, + "ATTGTAG": 3283, + "TCCGTTG": 3284, + "CTGCTGCG": 3285, + "CAAGCGCG": 3286, + "CAGCGACG": 3287, + "AATTTAT": 3288, + "TGAAAA": 3289, + "ATCTGGCG": 3290, + "CCTTTAA": 3291, + "AGGGTCG": 3292, + "AATGTTG": 3293, + "AGGGCGCG": 3294, + "TGCCTG": 3295, + "AAATCAG": 3296, + "CCGCCGCCGCCG": 3297, + "TTAAG": 3298, + "CCTCGAAG": 3299, + "CGGTGATG": 3300, + "TTTTGCA": 3301, + "TCCTGTG": 3302, + "TCCGCCGG": 3303, + "ACTCTTG": 3304, + "ACCTCGAG": 3305, + "TGTAT": 3306, + "TAGCGCG": 3307, + "CTTCATCA": 3308, + "CAAATTTT": 3309, + "TCCCCAG": 3310, + "AAAGATG": 3311, + "CCCAATT": 3312, + "ACAACAG": 3313, + "TGGAGCG": 3314, + "ATGGTAA": 3315, + "TACGGCA": 3316, + "CTGGCGCA": 3317, + "TCCCTTG": 3318, + "TATGAAG": 3319, + "CATGATT": 3320, + "CAAGTCA": 3321, + "CCAAGAA": 3322, + "TACAAAG": 3323, + "CACGAGCG": 3324, + "CCGCCCGG": 3325, + "CTTTTTCA": 3326, + "CAGACGG": 3327, + "TCCCGGCG": 3328, + "ACGTTCG": 3329, + "ACGCGAG": 3330, + "CTTCATCG": 3331, + "TTCATAA": 3332, + "TCAGGCA": 3333, + "ACGCAGG": 3334, + "CTGGTCGG": 3335, + "ACTCCCG": 3336, + "AAATAAG": 3337, + "ACCAGTT": 3338, + "TATTGAG": 3339, + "CCGCTCA": 3340, + "CAGTTTT": 3341, + "CTGGCGGG": 3342, + "ATGGCGAG": 3343, + "ACGAGCA": 3344, + "ATAGTAA": 3345, + "CCTGCGGG": 3346, + "CCGCGAGCG": 3347, + "ATTGTTTT": 3348, + "TATATAT": 3349, + "AATGATT": 3350, + "CTCCACA": 3351, + "TCGCGTCG": 3352, + "CTATGCG": 3353, + "TTTCATT": 3354, + "TACCAAG": 3355, + "CCGAGCTCG": 3356, + "CCACGGG": 3357, + "ACCCCAG": 3358, + "AAGGCGAG": 3359, + "TATTGCG": 3360, + "TTTGCGG": 3361, + "TCAGCTG": 3362, + "CGGCATGG": 3363, + "ACAACGG": 3364, + "AAGGCTG": 3365, + "ACCGCTT": 3366, + "CGGTGCTG": 3367, + "CAGCGTT": 3368, + "CCAATCG": 3369, + "CCGCCGAGG": 3370, + "ACTCTGG": 3371, + "TCTAATT": 3372, + "CCGGTCGG": 3373, + "CCCGGTT": 3374, + "CCGCGTGG": 3375, + "TGGCGCCG": 3376, + "ATCATTTT": 3377, + "CTCGCTCG": 3378, + "AAGGTAA": 3379, + "TGTTTCA": 3380, + "TGAATGG": 3381, + "TATGATT": 3382, + "TTCGCTG": 3383, + "CCAACAG": 3384, + "TGAATTG": 3385, + "ACTTTCG": 3386, + "CTTCGAGG": 3387, + "CCCACAG": 3388, + "TCTTCGAG": 3389, + "CAGGTAA": 3390, + "TCTGGGCG": 3391, + "TACTTGG": 3392, + "CTTGGTG": 3393, + "ACTAATT": 3394, + "CCGGGGGG": 3395, + "TCGGTTG": 3396, + "CGGTGAAG": 3397, + "CACATTG": 3398, + "ACCCTCA": 3399, + "TCCTCGCG": 3400, + "TCCTCGAG": 3401, + "AGAGCAG": 3402, + "AGCGCTT": 3403, + "CAGCATCG": 3404, + "CGGTGTCG": 3405, + "CCTCGGCA": 3406, + "TCTTGAT": 3407, + "CGCGCGAA": 3408, + "CGGTCGCG": 3409, + "CCCCACA": 3410, + "TGCAGAA": 3411, + "TCAGTGG": 3412, + "TCGGAAG": 3413, + "TATATTTT": 3414, + "ACGGCCGG": 3415, + "AGGATGG": 3416, + "TACCTCG": 3417, + "CTCTGAA": 3418, + "TCTGATG": 3419, + "CAAACTG": 3420, + "AACATGG": 3421, + "TTTTCTG": 3422, + "TCCAACG": 3423, + "TGTTGAG": 3424, + "TCAGCTT": 3425, + "TGGGGAA": 3426, + "TGAGCAG": 3427, + "TGGGCTG": 3428, + "CGGCGGAA": 3429, + "TGATCA": 3430, + "CCGTTGG": 3431, + "TCTACC": 3432, + "AGGGCCA": 3433, + "TCAGATT": 3434, + "ATCAGGCG": 3435, + "CAAAACT": 3436, + "AGGGAAG": 3437, + "CCGAGGCG": 3438, + "CGGGATT": 3439, + "CGGGCTT": 3440, + "TGACCA": 3441, + "CATTCCA": 3442, + "TACAGCA": 3443, + "CGGTAT": 3444, + "CCGCATG": 3445, + "AAAGTTG": 3446, + "ATAGAGG": 3447, + "TGCATG": 3448, + "CCGAGCAGG": 3449, + "TCTCTGG": 3450, + "TCCCAAG": 3451, + "ACCGCCGG": 3452, + "ATCGCTT": 3453, + "ATCCATT": 3454, + "CAGATCA": 3455, + "TGAAACA": 3456, + "CACACCA": 3457, + "ATATAAAA": 3458, + "CTTGCGCG": 3459, + "TCAGATG": 3460, + "TGGGATT": 3461, + "TTTTAAAA": 3462, + "TATAAAT": 3463, + "CTACGGCG": 3464, + "CACGCCCG": 3465, + "CGGGCGCA": 3466, + "CCATTGG": 3467, + "TGCGATG": 3468, + "TTCAAAAA": 3469, + "CCATTTG": 3470, + "ACGCGCTG": 3471, + "ACTACGG": 3472, + "ACAGATT": 3473, + "ACTCCTT": 3474, + "TATCCGG": 3475, + "CAAACTT": 3476, + "ACCTCGGCG": 3477, + "TACAAGG": 3478, + "AGAGCGG": 3479, + "TGAATCA": 3480, + "ACCGGTG": 3481, + "TGGAAAA": 3482, + "TCCCATT": 3483, + "AACGTCA": 3484, + "ATGTTGG": 3485, + "ATCCAGCG": 3486, + "TTAAAAG": 3487, + "CCGCCGCGG": 3488, + "CCTGGTT": 3489, + "TGGCGTCG": 3490, + "TGACGAA": 3491, + "AAGGCTT": 3492, + "CCCGATT": 3493, + "CTCAGAG": 3494, + "ACCCACA": 3495, + "TCTTTAT": 3496, + "ATAAAATT": 3497, + "TGGCGGCG": 3498, + "ACAATAA": 3499, + "ATACCTT": 3500, + "ACAGGCA": 3501, + "CATGTCA": 3502, + "CCTAAAG": 3503, + "ATGACCA": 3504, + "ATGTTCG": 3505, + "TCAGCGAG": 3506, + "ATCTACG": 3507, + "CCCGGCGCG": 3508, + "TGCGCTCG": 3509, + "TTTGAAAA": 3510, + "TGGTGGG": 3511, + "CCCGCAGG": 3512, + "CCCGATCG": 3513, + "ACCCATT": 3514, + "TATGTTG": 3515, + "CACGTAG": 3516, + "ATGATCA": 3517, + "CAGATTG": 3518, + "CCAGACA": 3519, + "AGCGCGGCG": 3520, + "ACGGCGGG": 3521, + "TCAGGGCG": 3522, + "CAGCAGCA": 3523, + "ACAGCGCG": 3524, + "CCTGTTCG": 3525, + "ATAAGCG": 3526, + "TCCGGTG": 3527, + "CTTTTTTG": 3528, + "TATCGAA": 3529, + "CCGCGTTG": 3530, + "CTGGCTGG": 3531, + "TCTCGCA": 3532, + "ACAAACA": 3533, + "ACGGCCAG": 3534, + "CCAACCA": 3535, + "CCTGGCGG": 3536, + "CTGCGCGG": 3537, + "TTTGTTTT": 3538, + "AAGATCA": 3539, + "CCGGCATCG": 3540, + "ACTTGTG": 3541, + "CCGGGCTG": 3542, + "CTATCCA": 3543, + "ATCTTTG": 3544, + "TCCCACA": 3545, + "AAGCAGG": 3546, + "AATTTCG": 3547, + "CTCGGCCA": 3548, + "TGGCGCTG": 3549, + "TATGATG": 3550, + "CCGTCAG": 3551, + "TCTGATT": 3552, + "AGCGTTG": 3553, + "ATATGAG": 3554, + "AATTCTT": 3555, + "CAAGCTCG": 3556, + "ACGCCAG": 3557, + "TGCAGAG": 3558, + "CCGGCGAGG": 3559, + "CAAACGG": 3560, + "TGAGCGCG": 3561, + "CATGCGCG": 3562, + "ACATCCA": 3563, + "ACGAAAA": 3564, + "TTCACGG": 3565, + "ACGGATG": 3566, + "ACCGATT": 3567, + "TGGATGG": 3568, + "ACGCGCTCG": 3569, + "TC": 3570, + "TGAAATG": 3571, + "ACGGGGCG": 3572, + "TGAGCGG": 3573, + "TATAATG": 3574, + "TGCTCCA": 3575, + "ACCTATT": 3576, + "ACTTATT": 3577, + "ACATCAG": 3578, + "CCGAGATCG": 3579, + "ATAATCG": 3580, + "CCTACTG": 3581, + "CTCGGCGCG": 3582, + "TGGCTCG": 3583, + "TCTCCCA": 3584, + "AAAGAAAA": 3585, + "CCTGTCA": 3586, + "TCTCCTCG": 3587, + "TGGCAGG": 3588, + "CCAGGTT": 3589, + "ATCAGTT": 3590, + "AGCGATT": 3591, + "ATCTCGAG": 3592, + "ACAGCTG": 3593, + "CACGATT": 3594, + "TGTGCG": 3595, + "CCGGGCGCG": 3596, + "CCCCCCA": 3597, + "CAGACT": 3598, + "ACATCCG": 3599, + "AAGGCGCG": 3600, + "TATCCAG": 3601, + "CCTTGCCG": 3602, + "ATATTTTTT": 3603, + "TAAATCA": 3604, + "CTTCCCA": 3605, + "TGTTTT": 3606, + "TTGTTGG": 3607, + "CAAACCG": 3608, + "CCCGCGGG": 3609, + "TTTGACG": 3610, + "TATTGAT": 3611, + "CAAAAGAA": 3612, + "AAAGAGG": 3613, + "TCGGCATCG": 3614, + "CTGGAGCG": 3615, + "TCGAGCAGG": 3616, + "AGGGGAA": 3617, + "CTATTTG": 3618, + "TAAAAAAG": 3619, + "CAGTGCG": 3620, + "TATGGAA": 3621, + "TAAAGTT": 3622, + "ACAGCTT": 3623, + "CCAATGG": 3624, + "TCGGACA": 3625, + "TGTTGG": 3626, + "CATGACA": 3627, + "CCTCAGCG": 3628, + "ATGAATG": 3629, + "TATTTCTT": 3630, + "TAAGATT": 3631, + "CTTCGTT": 3632, + "CTGCGGCG": 3633, + "AGGGTCA": 3634, + "CCAGCTTG": 3635, + "ACTACCA": 3636, + "TGCATGG": 3637, + "AAGCCCG": 3638, + "TATTGTG": 3639, + "CCACTCG": 3640, + "ACAGTGG": 3641, + "CACGCTGG": 3642, + "CTTCTCA": 3643, + "CACACCG": 3644, + "ACTGATT": 3645, + "TATTAAAA": 3646, + "ATTGGTT": 3647, + "AGAAAGAA": 3648, + "ACGCGTT": 3649, + "CAGTTGG": 3650, + "TGATGCA": 3651, + "AAGCGTT": 3652, + "CCGCGACCG": 3653, + "AACAACG": 3654, + "CCGCCGTG": 3655, + "TACATGG": 3656, + "TATTGGG": 3657, + "CCAAAGG": 3658, + "TCTACGG": 3659, + "TTTGACA": 3660, + "CTGAATG": 3661, + "CGGCTCA": 3662, + "CCACTGG": 3663, + "CCGGGGAG": 3664, + "CACAACG": 3665, + "TAAATTG": 3666, + "ATAGGAA": 3667, + "TATGGAG": 3668, + "TAGATAA": 3669, + "CTATGGG": 3670, + "ACCTCGCCG": 3671, + "CGGCCCGG": 3672, + "AGCGCCTG": 3673, + "CCTTCTTG": 3674, + "CCCCCGCG": 3675, + "TCGACCA": 3676, + "TTGCGCA": 3677, + "CTCGCGAG": 3678, + "CTCCTGCG": 3679, + "CGGCGGTG": 3680, + "CGGTTGG": 3681, + "CTGTTCA": 3682, + "TCCAATG": 3683, + "CGGACT": 3684, + "CAGCATCA": 3685, + "AGGACT": 3686, + "CCTCGTT": 3687, + "CCGGACGG": 3688, + "AGGTTTT": 3689, + "CCGTCGCG": 3690, + "ATCGTCGG": 3691, + "AGGAGAA": 3692, + "TACGCCA": 3693, + "TCCCCTG": 3694, + "TCTCTCG": 3695, + "ATGATAA": 3696, + "CAGGTCGG": 3697, + "ACCTATG": 3698, + "CCGGAGCG": 3699, + "ATACGAA": 3700, + "AAGCGGG": 3701, + "TGCCGTCG": 3702, + "ACAAAGG": 3703, + "CTCGGCGAG": 3704, + "ATAAGGG": 3705, + "CCAGTTCG": 3706, + "TATACTT": 3707, + "TCCAGTT": 3708, + "CTTTATG": 3709, + "CCGTCCA": 3710, + "AGGCTGG": 3711, + "CCGACAG": 3712, + "ACATGAA": 3713, + "ACCTCGACG": 3714, + "TACATTG": 3715, + "ATCCCGAG": 3716, + "CGGCCTT": 3717, + "CATCGCA": 3718, + "CTCTGAG": 3719, + "TGTTTG": 3720, + "TAAAATAA": 3721, + "TAAGGCG": 3722, + "TACCGAG": 3723, + "TATCAGG": 3724, + "TATAGAA": 3725, + "AAGACGG": 3726, + "CCCTCTT": 3727, + "AAAACAAA": 3728, + "CAGTTTG": 3729, + "CCATGGG": 3730, + "CTGCGTT": 3731, + "AAGACCG": 3732, + "TGGACGG": 3733, + "TAGATGG": 3734, + "ACTCATT": 3735, + "CCGAGAA": 3736, + "CTTGTAA": 3737, + "ACCTTCT": 3738, + "TGAATAA": 3739, + "ACGTGCG": 3740, + "CCGTGGG": 3741, + "TCCTGGCG": 3742, + "ATCACTT": 3743, + "CAAGATCG": 3744, + "ATATACA": 3745, + "TGTTTGG": 3746, + "TCTTTCT": 3747, + "TCCTCGGG": 3748, + "ACTATTG": 3749, + "TTCATCT": 3750, + "ATACCTG": 3751, + "TTGCAGG": 3752, + "ATAACTT": 3753, + "TCGCGTG": 3754, + "CGAGCAG": 3755, + "ATTCCGG": 3756, + "AGGTGCG": 3757, + "TCAGCTCG": 3758, + "ATAAAGAA": 3759, + "CGAGCGG": 3760, + "CGGCGGCGGCGG": 3761, + "TTGGACA": 3762, + "TATCTCG": 3763, + "AGGCGCTCG": 3764, + "TCCGCTT": 3765, + "TTGACCG": 3766, + "CCTTGTT": 3767, + "TGCTGTT": 3768, + "TATCTAA": 3769, + "TTGCCCG": 3770, + "TCGCCGCG": 3771, + "CCAGGCGG": 3772, + "CCTGACCG": 3773, + "ACGCGCCG": 3774, + "CGGGTGCG": 3775, + "AAGAACA": 3776, + "AAAATTAA": 3777, + "ATATCAG": 3778, + "CCGGCATG": 3779, + "ACTACCG": 3780, + "ATCTGTT": 3781, + "TCGGCCCG": 3782, + "TTGGACG": 3783, + "CTATGAA": 3784, + "TCCTGCCG": 3785, + "TCTGCGCG": 3786, + "CCGGCGCGG": 3787, + "TCGAGCGG": 3788, + "CCTGGTGG": 3789, + "TTTTACA": 3790, + "CTCAGAA": 3791, + "CGGGACA": 3792, + "CGGGCCAG": 3793, + "CCCTCAG": 3794, + "TCTTCCG": 3795, + "ACTGGGCG": 3796, + "CGGGGTCG": 3797, + "TGCAAGG": 3798, + "ATCGACGG": 3799, + "AAATCAAA": 3800, + "AAAATGAA": 3801, + "TCATCAG": 3802, + "AATTCCA": 3803, + "CCCTCGGCG": 3804, + "CCGGGCAG": 3805, + "TAACAAA": 3806, + "AGGGGCA": 3807, + "CAGGGGCG": 3808, + "ATAAGAG": 3809, + "ATGATTG": 3810, + "TTTGTAG": 3811, + "TACGCGG": 3812, + "TGATTG": 3813, + "AAGACC": 3814, + "TTTGCTT": 3815, + "TCGTCGTCG": 3816, + "CCAGCAGCG": 3817, + "CCTTCACG": 3818, + "CAGGATCG": 3819, + "TGATCAG": 3820, + "ATGAACA": 3821, + "CCCAGTT": 3822, + "ACGGACA": 3823, + "ATGCGTT": 3824, + "TGGGACA": 3825, + "TGTCT": 3826, + "AAATCGG": 3827, + "ATAGCCG": 3828, + "CCCGCACG": 3829, + "ACTAAAG": 3830, + "TCTTTAG": 3831, + "ATCTCAG": 3832, + "TCGGATT": 3833, + "TCCTCGGCG": 3834, + "CCCCGGGG": 3835, + "TGGAAGG": 3836, + "TTGGCTT": 3837, + "CGCGATT": 3838, + "ACCGGTT": 3839, + "TATCGCA": 3840, + "CGCGCTT": 3841, + "ATGCAAA": 3842, + "TATAAATT": 3843, + "TACTGCA": 3844, + "TCCGCCAG": 3845, + "ACCTCGGG": 3846, + "TTTTTGAA": 3847, + "CTGCGCCA": 3848, + "ACAGAGG": 3849, + "CTCTATT": 3850, + "AAGAAAAG": 3851, + "AGCGCCGG": 3852, + "CGGGTAG": 3853, + "TGCGTCA": 3854, + "TACGACA": 3855, + "CTGGATCG": 3856, + "TCGCCAG": 3857, + "ACCATCT": 3858, + "ACGGATT": 3859, + "TCGAGCCG": 3860, + "ACCCCCA": 3861, + "TGATCCA": 3862, + "TGGCGAAG": 3863, + "AGGGTTG": 3864, + "ATACGAG": 3865, + "CGGCGTCGG": 3866, + "TACCTTG": 3867, + "CGGGCAAG": 3868, + "CCCTTGCG": 3869, + "TAATCC": 3870, + "ACTCTCG": 3871, + "CAGCGAGG": 3872, + "TGTCC": 3873, + "AGCATCT": 3874, + "AGAGATT": 3875, + "CAGAATG": 3876, + "ACTGTCA": 3877, + "AACGAAG": 3878, + "ATCGTCT": 3879, + "TGCACCA": 3880, + "CTTGCTT": 3881, + "CCGAGAAG": 3882, + "AAAAACTT": 3883, + "CGAGCCG": 3884, + "TACGTCA": 3885, + "AGTTTGG": 3886, + "AACGACA": 3887, + "TAGGTGG": 3888, + "TGCAACA": 3889, + "ACGGCGAA": 3890, + "CCGAGACG": 3891, + "CCCGCGCA": 3892, + "CGGATTG": 3893, + "CCCGCCTG": 3894, + "CAAGTAA": 3895, + "TATCCTG": 3896, + "ACAGTCA": 3897, + "AGGGCTG": 3898, + "AAAAATTG": 3899, + "TCTTATT": 3900, + "CCCATCT": 3901, + "AAAGTAA": 3902, + "CCGCGCAGG": 3903, + "TCGCCGTCG": 3904, + "CGCGCCAG": 3905, + "AACACCG": 3906, + "TCGGATG": 3907, + "TATTACA": 3908, + "TATTTTAA": 3909, + "CTGGTAA": 3910, + "AAAACTG": 3911, + "AGGAATT": 3912, + "TGCGTTG": 3913, + "TTCATTTT": 3914, + "CTGGCTT": 3915, + "CCCGTAG": 3916, + "CGGATCA": 3917, + "TACCGCA": 3918, + "CCCGACCG": 3919, + "ACTGTCG": 3920, + "ACCCCTG": 3921, + "CAAGCTT": 3922, + "CCCACTG": 3923, + "CCTTTGCG": 3924, + "CAGTCT": 3925, + "CACGACCG": 3926, + "TCCGCTCG": 3927, + "CGGCGATGG": 3928, + "TGCAATT": 3929, + "CTAAAAAA": 3930, + "TGCAAAG": 3931, + "TTCGCCGG": 3932, + "TGAAGCA": 3933, + "CTCATCT": 3934, + "CTAATTG": 3935, + "AATGCCG": 3936, + "TGCTGCTG": 3937, + "ACTGACG": 3938, + "TCTGCTT": 3939, + "CAGACCA": 3940, + "ATCTCTG": 3941, + "ATATATG": 3942, + "TGCCGTT": 3943, + "CCACGTG": 3944, + "TCGCGATG": 3945, + "TCGAGCTCG": 3946, + "CTCCATT": 3947, + "TAGAGAA": 3948, + "CCTTCCAG": 3949, + "CAAGCGCA": 3950, + "TACACCA": 3951, + "CCCGGGGG": 3952, + "TTTTATG": 3953, + "ACAATGG": 3954, + "CTCTCTT": 3955, + "TGCGAAG": 3956, + "TCGGCGTCG": 3957, + "TCGAGCTG": 3958, + "CGGCCAGG": 3959, + "AACATTG": 3960, + "CGGCGCAGG": 3961, + "CCGGGACG": 3962, + "CAGCCGCG": 3963, + "TGATGTT": 3964, + "CCGACGCG": 3965, + "CCGGTCT": 3966, + "TCAGTCA": 3967, + "AACGTGG": 3968, + "CCTTTTCG": 3969, + "ACGGCCTG": 3970, + "CCTTCCTG": 3971, + "AGGGATT": 3972, + "ACGAGCGCG": 3973, + "CCCCGACG": 3974, + "TACCTCA": 3975, + "AGGCGATG": 3976, + "TAGTTGG": 3977, + "CTCTCTG": 3978, + "CGGCTGCG": 3979, + "CGGGCGAA": 3980, + "TCAGCAGG": 3981, + "TAAGAAG": 3982, + "TCGTTCG": 3983, + "TAGAAGG": 3984, + "TCGACT": 3985, + "AGGGCTT": 3986, + "ACGGCTCG": 3987, + "CCCGCGGCG": 3988, + "AAATCTG": 3989, + "TCTTCGCG": 3990, + "TCTGTGG": 3991, + "CCTATAA": 3992, + "TCTGCTCG": 3993, + "TAGTATT": 3994, + "CAGCATT": 3995, + "ATATTTTG": 3996, + "ACTTCTG": 3997, + "CCAGCATG": 3998, + "CAGGCTT": 3999, + "ACTTCGAG": 4000, + "ATACACG": 4001, + "TCCATAA": 4002, + "CCGGTGCCG": 4003, + "TACAGAA": 4004, + "ATATCTG": 4005, + "CGGCGGCCG": 4006, + "TACGAAG": 4007, + "TCAGCACG": 4008, + "CAAGGCA": 4009, + "AGGAACG": 4010, + "CAGGCGCA": 4011, + "CTACGAA": 4012, + "TCGGCGACG": 4013, + "CCCTGTT": 4014, + "ACTCGCA": 4015, + "AGCACGCG": 4016, + "ATATCGG": 4017, + "CTATCC": 4018, + "TCCATCT": 4019, + "TGTCCG": 4020, + "CCATCGCG": 4021, + "CCCACGCG": 4022, + "CACAATT": 4023, + "ACCTCGTCG": 4024, + "ATATAAG": 4025, + "CCGCGACA": 4026, + "CCTAATT": 4027, + "TCTGTCA": 4028, + "TCCTTCT": 4029, + "ACTATAA": 4030, + "CAGTCGG": 4031, + "ACAGACA": 4032, + "AGGTAT": 4033, + "CCTTCGGG": 4034, + "TCTTTCTT": 4035, + "ATCATCGG": 4036, + "ATCCTGCG": 4037, + "ATCACCGG": 4038, + "CGGCGACCG": 4039, + "AATGTCA": 4040, + "CCGGGTGG": 4041, + "CGGTGCGG": 4042, + "CAAAGCA": 4043, + "CGCGCGCCG": 4044, + "CCACGTT": 4045, + "TCTCATT": 4046, + "CTCGCCGCG": 4047, + "TGCAAG": 4048, + "TAGATCG": 4049, + "CAAATATT": 4050, + "ACGAGAA": 4051, + "AAAGTCA": 4052, + "CCCATGCG": 4053, + "CCAGTAA": 4054, + "AGGGCAAG": 4055, + "TAGCGCA": 4056, + "AAAGCCA": 4057, + "TGACT": 4058, + "CAGCGTCA": 4059, + "CTACGACG": 4060, + "AGGTCC": 4061, + "CCGAGCACG": 4062, + "AATTTATT": 4063, + "ACGCTCA": 4064, + "AAAGCCG": 4065, + "CGGGAGCG": 4066, + "ACAACCA": 4067, + "CAGCGTGG": 4068, + "CCGGCCTCG": 4069, + "CTGGCGAG": 4070, + "CCGGTAA": 4071, + "CGGGTCGG": 4072, + "ACGCCGCG": 4073, + "ATACTTG": 4074, + "CTCGATGG": 4075, + "CTGGCCCG": 4076, + "CCTGCTTG": 4077, + "ATAGTCA": 4078, + "CCCTCTG": 4079, + "TAAGTAA": 4080, + "CTGGTGCG": 4081, + "TGATCTT": 4082, + "TGCATTG": 4083, + "TAGTCGG": 4084, + "CCGACGAA": 4085, + "TGAAAGG": 4086, + "CTACATT": 4087, + "TCGAGAA": 4088, + "ACTGTGG": 4089, + "TTCGCAG": 4090, + "ACTTCCG": 4091, + "CATTCTT": 4092, + "CAAAATAA": 4093, + "TCCGATT": 4094, + "ACGAGCTG": 4095 + }, + "merges": [ + "C G", + "C A", + "T G", + "A A", + "T T", + "A G", + "C C", + "CG G", + "C T", + "A T", + "CA G", + "TG G", + "C CG", + "C CA", + "C TG", + "T CG", + "C TT", + "AA G", + "AG G", + "A CG", + "A TT", + "A TG", + "C CGG", + "T TG", + "A CA", + "T CA", + "CAG G", + "CG CG", + "CGG G", + "C TGG", + "T AA", + "A CC", + "CT CG", + "C CAG", + "T CC", + "T AG", + "G G", + "AA AA", + "A CT", + "T AT", + "T CT", + "A TGG", + "CGG CG", + "CC CG", + "TT TT", + "AT CG", + "CC TG", + "A CCG", + "T CGG", + "CA CG", + "T TGG", + "CT TG", + "A CGG", + "CA AG", + "CA AA", + "AAG G", + "A CCA", + "AG CG", + "T CCG", + "TGG G", + "CA TG", + "TT CG", + "AT TG", + "A CTT", + "T CTT", + "T CCA", + "A CAG", + "TT TG", + "T ATT", + "AT CA", + "AT AA", + "AGG G", + "T CAG", + "C CAGG", + "CCG CG", + "AG AA", + "A CTG", + "TG CG", + "CT CA", + "CC TT", + "CC CA", + "CCGG G", + "T CTG", + "TG AA", + "AG CA", + "TT CA", + "CC TCG", + "T ACA", + "AA CG", + "AA TT", + "AA AG", + "T ACG", + "CAG CG", + "CGGG G", + "T ATG", + "AG AG", + "CC CGG", + "CC TGG", + "AA TG", + "T AGG", + "CG AG", + "AT CT", + "CA TT", + "AT AG", + "CTGG G", + "T AAG", + "CA CA", + "CCG CCG", + "A CCGG", + "TG TG", + "CT CT", + "TCG CG", + "TGG CG", + "CAGG G", + "CTG CG", + "AA CA", + "CT CGG", + "CCG AG", + "TG AG", + "CTT CG", + "TG CA", + "AA AT", + "ATT TT", + "TG TT", + "CCA CG", + "CCGG CG", + "CC T", + "CC CT", + "CGG CA", + "A CCAG", + "CC TTG", + "AT AT", + "ACG CG", + "AG TT", + "AGG CG", + "CGG TG", + "TCG AG", + "T CGGG", + "CC CAG", + "CC CCG", + "T ACC", + "GG G", + "CGG CGG", + "A CGGG", + "A CTGG", + "T CCGG", + "TG CCG", + "T ACT", + "TG AT", + "CAG CA", + "CG CA", + "CC CTG", + "CT AA", + "CCG CA", + "T CCAG", + "CTT TT", + "CGCG CG", + "TG CTG", + "CC TCA", + "ACG AG", + "CTT CA", + "AT ATT", + "T CTCG", + "A CAGG", + "TG CT", + "AA ATT", + "ATGG G", + "T CTGG", + "T CAGG", + "ATG CG", + "AAG CG", + "A CTCG", + "CC TCC", + "T CGGCG", + "CCA AG", + "CA TCG", + "AT CGG", + "CT TGG", + "TT AA", + "CCG TG", + "AAG AA", + "AT CAG", + "CC CC", + "CGG AG", + "TG ATG", + "AAG GG", + "ACC CG", + "A CGGCG", + "AT CTG", + "AGG AG", + "TGG GG", + "CT AG", + "TCA CG", + "CCA TG", + "CCG AA", + "CGGG CG", + "TAA AA", + "CCA AA", + "TCC CG", + "AT TGG", + "CTG CA", + "TTGG G", + "CC CGCG", + "TTG CG", + "CT CCG", + "TCG CCG", + "CGG CCG", + "AT CCG", + "AT CTT", + "TGG TG", + "ATG AA", + "TT TTG", + "AAG AG", + "CT CCA", + "ACC TG", + "CC CCA", + "AGG GG", + "CCAG CG", + "ACA AG", + "ACA AA", + "CA TCA", + "TGG AG", + "TT CT", + "ATT CG", + "ACA CG", + "TCG TCG", + "CTT TG", + "AT CCA", + "CCG ACG", + "CTGG CG", + "TT AG", + "CT CC", + "TG AAG", + "CGG AA", + "TG ACG", + "ATG AG", + "TT TCA", + "TCG AA", + "TG CAG", + "CA CCG", + "AGG AA", + "TTG AA", + "CCAGG G", + "T ACTT", + "TGG AA", + "CTG CTG", + "CA AT", + "CT CTT", + "ACG AA", + "TG CGG", + "CT CAG", + "TCA AG", + "TAA TT", + "CTG AA", + "CT CGCG", + "ACCG CG", + "CC CTT", + "TCA AA", + "CCGG GG", + "AT CGCG", + "CA AGG", + "TG TTG", + "TCG ACG", + "AAAA AA", + "CAG AA", + "CCA TT", + "TGG CA", + "TAT CG", + "CAGG CG", + "CCG CGG", + "CTG AG", + "AT CC", + "ATT TG", + "AAG TT", + "CCG TCG", + "CA ACG", + "T ACCA", + "CAG AG", + "CA ACA", + "TTG AG", + "TG TCG", + "T ATGG", + "ATT AA", + "CA CCA", + "ACG ACG", + "CT CTG", + "T ACAG", + "ATG TT", + "CCG AGG", + "CAG CAG", + "TAA AG", + "CC TCGG", + "CA AAG", + "T ACCG", + "TCC TG", + "T ACTG", + "TCT TG", + "CCG TT", + "CG AA", + "ACA TT", + "CC CTCG", + "CGG TCG", + "TTG TT", + "CC TTCG", + "ACC TT", + "CCG CCA", + "T ACGG", + "CT ACG", + "CTG TT", + "A CCAGG", + "ATGG CG", + "AGG TG", + "CA TGG", + "AT ATG", + "CA ATT", + "CT ATT", + "TCG TG", + "CCTG CG", + "TCA TT", + "TCCG CG", + "CGG TT", + "CA TTG", + "CA ATG", + "CT AT", + "TTTT TT", + "CGCG AG", + "TCG AGG", + "TAG CG", + "AAGG CG", + "TCC TT", + "CC CTGG", + "CAG TT", + "TGGG CG", + "TGG TT", + "CC TCT", + "CT ACA", + "AT AAAA", + "CCG CTG", + "CTCG AG", + "CA CGG", + "TAT AA", + "CCA TCG", + "AAG AAG", + "AT ACA", + "CC CGGG", + "AG TG", + "CC CAGG", + "A CCGGG", + "CC CCGG", + "ACG CCG", + "AT CTCG", + "ACT TG", + "CCG ATG", + "TAT TG", + "TCA TG", + "TAG AA", + "AGGG CG", + "ACC TCG", + "ACG TG", + "AAG CA", + "CGG TGG", + "TTGG CG", + "CGG CTG", + "CGG CAG", + "ATCG AG", + "CCA CA", + "TAG AG", + "CGG CCA", + "CCGG AG", + "AGG TT", + "T CCAGG", + "TCG TT", + "ATT CA", + "CC TCCG", + "ACA TG", + "AT AAG", + "CGGG GG", + "TCAG CG", + "TCTT CG", + "T AAGG", + "TCC TCG", + "CCCG AG", + "CT ATG", + "CGG CGCG", + "AT CCGG", + "CTG CCG", + "CC TGGG", + "AT ACG", + "TGG TGG", + "AAG TG", + "TCG ATG", + "CC TTGG", + "AAAA TT", + "CAG TG", + "CCA CCA", + "CCGG CA", + "CCGG TG", + "ACC TGG", + "CT CGGG", + "ATG ATG", + "AT CAGG", + "ACG AGG", + "T CGGGG", + "AAAA AG", + "T CCGGG", + "CC CACG", + "TTG CA", + "CCG AAG", + "CTGG GG", + "ACC CA", + "TAT CA", + "ATG CA", + "TAA TG", + "AGG CA", + "ACG TT", + "AG CAG", + "AA AAG", + "T AGGG", + "CTG TG", + "CCG CAG", + "CC TCCA", + "TCA TCG", + "TATT TT", + "TCC CA", + "AT CTGG", + "CTT CTT", + "TAA CG", + "CAAG CG", + "ATG TG", + "CGG CT", + "CC CTTG", + "CCG CT", + "ATT TTG", + "TAG TT", + "AT CACG", + "ACCA CG", + "CCA TCA", + "AG AAG", + "AGG AGG", + "TCG CGG", + "TCG CA", + "AG CTG", + "ACTT CG", + "CCG TGG", + "ACG CA", + "ATT ATT", + "CC TAA", + "AT CCCG", + "TCA TCA", + "CTTG CG", + "AT CAAA", + "CCAG CA", + "CT CGGCG", + "AT AGG", + "TTG TG", + "AA TAA", + "ACAG CG", + "ACG TCG", + "CC TTTG", + "CC CATG", + "CAG CGG", + "ACG ATG", + "CC CCCG", + "AT CGGG", + "CCA CCG", + "TGG CGG", + "CC TAT", + "CC TTTT", + "ACT CA", + "CT CCGG", + "TT CTT", + "ATT TAA", + "A CGGGG", + "AG CGG", + "CT CCAG", + "AT CTTG", + "TCT CA", + "CCA AGG", + "ATG AAG", + "CC CGGCG", + "TCC TGG", + "TG AGG", + "ACT AA", + "ATT AG", + "CAG CCG", + "CTGG AG", + "TCCA CG", + "ACA TCG", + "CTT AA", + "TAT AG", + "AT CAAG", + "AT CCTG", + "TTG TTG", + "AT CCAG", + "CTG CGG", + "ATG CCG", + "CT CCTG", + "TAA TAA", + "A CTGGG", + "TCG AAG", + "CT CTCG", + "CAGG GG", + "TGG CCG", + "AT ATTG", + "ATT TTTT", + "CC CCAG", + "TCT AA", + "ATT TCA", + "ACG AAG", + "CTG CAG", + "ACG CGG", + "TT CGG", + "TT TCG", + "CCG CCGG", + "TG CCA", + "AT CATG", + "ACC TTG", + "ACA CA", + "ACA TCA", + "CCG CGCG", + "ATAA TT", + "AA TTG", + "CT CAAG", + "TCTG CG", + "TCC TTG", + "AT ACT", + "AA ATG", + "AGG CGG", + "CAGG AG", + "ACC CGG", + "CTT TTG", + "CTG AAG", + "CCGGG CG", + "TT TGG", + "CT ACT", + "TG CGCG", + "CGGCG AG", + "CAAA AG", + "CTG ATG", + "CCGG AA", + "TG TGG", + "CCA TGG", + "CC TCTT", + "ATGG GG", + "TCGG CA", + "AGG TCG", + "CATG CG", + "ACA ACA", + "CT CCCG", + "CTT CGG", + "TT CCA", + "CCG TCA", + "AGG AAG", + "T CTGGG", + "CCG TTG", + "CGCG CA", + "CT CACG", + "CCGG CGG", + "CCG ACA", + "CC CAAG", + "CTGG AA", + "TGG TCG", + "ACCG AG", + "ACG CTG", + "CGCG AA", + "CTCG AA", + "AGCG AG", + "TCA CA", + "TAG CA", + "CT CTTG", + "T CAGGG", + "CTGG TG", + "CAGG AA", + "ACGG CA", + "TT CAG", + "TT TAA", + "TTGG GG", + "TTG ATG", + "CT AAG", + "TG ATT", + "TTG AAG", + "CC CCTG", + "CCA CGG", + "CC TACG", + "CCA AAG", + "CC TAG", + "CACG AG", + "CAAA CG", + "CGGG AG", + "CAG AAG", + "A CAGGG", + "T ACCGG", + "TTCG AG", + "ATTG CG", + "AGG CCG", + "TAA CA", + "TG CTT", + "ATCG AA", + "CCA ACG", + "TTTT CG", + "CT CTGG", + "CT ACC", + "CAG CTG", + "ACTG CG", + "TG CTCG", + "AT ACC", + "AT ATAA", + "CGG ACG", + "CCTT CA", + "TAA ATT", + "CCA ACA", + "CCA TTG", + "TCG CTG", + "AAGG AG", + "CGGG CA", + "CAG CGCG", + "CCCG CA", + "ATGG AG", + "TT CTG", + "TCC CGG", + "ATG TCG", + "CT AAAA", + "ATG CTG", + "CTT TCA", + "TGG AAG", + "AGAA CG", + "CC CAAA", + "AA ACA", + "TCGG TG", + "TGAA CG", + "CGG AAG", + "CC TCTG", + "AA TCG", + "CTT AG", + "CTCG CCG", + "AAAA CG", + "T ACTGG", + "AA TGG", + "TAGG CG", + "TT ATT", + "TT CCG", + "CT CAGG", + "CGG TCA", + "TG ACA", + "CGCG CCG", + "AT CGGCG", + "CT CATG", + "CT CAAA", + "AA TCA", + "T ACCAG", + "ATG ACG", + "AGAA AG", + "ACC TCA", + "ATAA AG", + "TCT AG", + "AT ATCG", + "CTT TGG", + "ATG TTG", + "CCTG CA", + "CTT CAG", + "CGG AGG", + "CC CTCA", + "CC TCAG", + "CTCG ACG", + "CTGGG CG", + "TCC TCA", + "TG TCA", + "CTG TTG", + "ATT TCG", + "CTG ACG", + "TTTG CG", + "TG TAG", + "T ACTCG", + "AGG ACG", + "TCGG AG", + "TG CCGG", + "AA CAG", + "ATG CGG", + "CTT TCG", + "AGG TGG", + "CT TGGG", + "CTT CCA", + "TCTT TT", + "CCAG AA", + "CCAGG CG", + "ACA AAG", + "CCAG AG", + "TTG CCG", + "CTG TCG", + "CTG CGCG", + "TG CTGG", + "ACT AG", + "CTTG AG", + "TAT ATT", + "CGG CCGG", + "ACA AGG", + "TAA AAG", + "TAA AAAA", + "CCTCG CG", + "AA AGG", + "TG ATCG", + "CC TACA", + "ACCA AG", + "CAG CCA", + "ACCGG CG", + "CTT CT", + "ACTT TT", + "TACG CG", + "CTT CTG", + "TCG CCA", + "TCTT CA", + "AT ATCA", + "CGG CGGCG", + "CGG ATG", + "CCGG CCG", + "CAAG AA", + "CTCG TCG", + "CGG CGGG", + "CCCG AA", + "CAG ATG", + "ATTG AA", + "ACG CCA", + "AT TGGG", + "ATGG AA", + "ACG ACA", + "CC CCCA", + "TTTT TG", + "TCT TGG", + "ACG TGG", + "ACGG AG", + "CTG CCA", + "CAAG AG", + "T ACAGG", + "TCG TCA", + "CTG CTCG", + "AT CTCA", + "AAG CCG", + "AGCG CA", + "CCGCG AG", + "TTTT CA", + "TAG TG", + "CT AGG", + "CAAA TT", + "TCG TGG", + "TTTT AA", + "TCCG AG", + "TATT CG", + "ATT TGG", + "CAGGG CG", + "ACCG CA", + "TCAG CA", + "CGGG AA", + "CTT CCG", + "TTGG AG", + "TAG AAG", + "CCTGG CG", + "AAGG AA", + "CAG CT", + "AAAA CA", + "AGG ATG", + "TT CGCG", + "TTG CTG", + "TCA CCG", + "ATGG CA", + "TCT CGG", + "CTGG CA", + "ACGG TG", + "CTT TAA", + "ACC CCG", + "CCA ATG", + "CGGGG CG", + "CTTG AA", + "CCCG CCG", + "ACA TGG", + "AAG ATG", + "TCC CAG", + "T CCGGCG", + "TT TCT", + "ACTT CA", + "CTG CT", + "CGG CTT", + "ATGG TG", + "AT ACCA", + "CGG TTG", + "AT AGAA", + "CC TATG", + "ACC CAG", + "TTTG AA", + "ATCG TG", + "TCT CCA", + "ACAG CA", + "AAAA TG", + "CCTG AA", + "ACA TTG", + "CGGG TG", + "AGG GGG", + "ATCA TT", + "CAG TTG", + "TGAA AG", + "ACA ATT", + "AT ACTT", + "CACG AA", + "CC CAGCG", + "ATCG CCG", + "AT ACCG", + "CCTG AG", + "TCG TTG", + "CTG CTGG", + "AT CCCA", + "ATG ATT", + "T ACGGG", + "AAAA ATT", + "ACG TCA", + "ACG TTG", + "CAGG TG", + "ATTG AG", + "CAG CTT", + "TGG TCA", + "TGG GGG", + "CT CCTCG", + "TGG ATG", + "TGG CTG", + "ACCA AA", + "CAGG CA", + "TCCG CA", + "CCA ATT", + "CT CCTT", + "TGG AGG", + "ATCG CA", + "AT ATGG", + "AAG CTG", + "TGCG AG", + "TAA TTG", + "CGCG TG", + "TGGG AG", + "CTT TTTT", + "ACA ACG", + "CTGG CCG", + "AGG TCA", + "ACA CCG", + "AGG TTG", + "TCCA AG", + "AAGG CA", + "TCC CCG", + "TGG ACG", + "CCGG TT", + "TGG CCA", + "CATG AA", + "TAG CCG", + "TCA AAG", + "TCT CCG", + "TCGG CGG", + "CAG ACG", + "TTGG AA", + "TGCG CA", + "ACA CCA", + "CAAG CA", + "ATT TAT", + "CCT CGGCG", + "ACA ATG", + "CAG CAGG", + "ACC CTG", + "AAG GGG", + "CAG CTCG", + "TCC TCC", + "CCCG TG", + "AT ATTTT", + "CGG CTCG", + "CGCG ACG", + "CATG AG", + "AT ACTG", + "AGCG TG", + "CC TATT", + "CCAG TT", + "AAGG TG", + "TGG TTG", + "TAG ATG", + "CAAA CA", + "AAG CGG", + "TCCA AA", + "CAG TCG", + "AT CCTT", + "AAAA TAA", + "AAG TTG", + "TT TAT", + "CCG CTCG", + "TAG TTG", + "AACG AG", + "CC CCTT", + "AGGG AG", + "TTTG AG", + "AAG ACG", + "CGCG CGG", + "CT CCCA", + "CT ACCG", + "CCG CTT", + "TGG CAG", + "CCGG TCG", + "TCA AGG", + "CT ATTG", + "CACG CCG", + "AT CAGCG", + "TAA ATG", + "TCA CCA", + "AAG AGG", + "ATT CTT", + "AT ACAG", + "TGGG CA", + "CGGG CGG", + "AGAA TT", + "ACT TGG", + "AAG TCG", + "TATT AA", + "CCGG CGCG", + "ACCG TG", + "TACC CG", + "CC CCGCG", + "TACA CG", + "GG CG", + "CACG CA", + "CTG CTT", + "CCG CCCG", + "AAG ATT", + "TCA TTG", + "CC CTCGG", + "ACGG AA", + "AAAG AG", + "TAG TAG", + "AGCG AA", + "TTGG CA", + "TTGG TG", + "ACCAG CG", + "AGGG CA", + "ATTG TT", + "CGCG TCG", + "ATG AGG", + "CTCG CA", + "TAA TTTT", + "CTCG TG", + "TCTG CA", + "TCA ACA", + "ACCG AA", + "ATG CAG", + "TAT TGG", + "AT CCGCG", + "TCTT TG", + "ATT CCA", + "ATCG TCG", + "TTTG TT", + "CCAG CAG", + "CT ACGG", + "CCT CGGG", + "AGG CCA", + "T ATGGG", + "TATT TG", + "ATG CCA", + "ACT CCA", + "TCGGG CG", + "CT ACTT", + "AGG CTG", + "AATT AA", + "TCGG AA", + "TAA TCA", + "TCT CTT", + "AAG CAG", + "CGG CTGG", + "TTCA TT", + "GG GG", + "TTTT AG", + "AAAA AAAA", + "TTCG AA", + "CGG CCAG", + "CCTG TT", + "AT AGCG", + "CAG TGG", + "TCA ACG", + "ACT ATT", + "ACC CCA", + "AT ATAG", + "AT ACGG", + "TAT CTT", + "CT CCGCG", + "CTGG TT", + "TCA ATT", + "TCA TGG", + "CGCG CGCG", + "CT ATCG", + "CCG AGCG", + "ATAA CG", + "CCTCG AG", + "TCG ACA", + "CT CTCA", + "CTG CCGG", + "TACA AA", + "ATTG CA", + "CAAA TG", + "CT ACCA", + "AT AGAG", + "TCG CCGG", + "CTG ATT", + "ACT ACA", + "ACT CGG", + "TT TCC", + "CTGG CGG", + "CTTG CA", + "CTG TGG", + "CTT CGCG", + "TCT ATT", + "ATCG ACG", + "CTCG AGG", + "ACT ACG", + "TCCA TG", + "CAG ATT", + "TCAG AA", + "CCG CCAG", + "TATT CA", + "CTGG TCG", + "CCCA CA", + "TACG AG", + "TAG TCG", + "CT ACTG", + "ACAG AA", + "TTG TCG", + "CGG CACG", + "CT AAAG", + "CC CTCT", + "CCG ACC", + "CAG CACG", + "TACA AG", + "CTCG CGG", + "AAAA AAG", + "TGAA TT", + "TCCG AA", + "ATGG TT", + "TCT ACA", + "TAG AGG", + "TTTG CA", + "CAG AGG", + "TTG ATT", + "TGGG AA", + "CAGG TT", + "ACCA TG", + "CTG ATCG", + "TTG ACG", + "TCC CCA", + "A CCAGGG", + "TAA ACA", + "AAG CCA", + "ACAG AG", + "CCT CCGG", + "CGGG CCG", + "CCAG TG", + "TCA ATG", + "ACGG CGG", + "TATG CG", + "CAG CCGG", + "ACTT TG", + "AT AAGG", + "CTTG TT", + "AGAG AG", + "CATG CA", + "CGGG TT", + "TCT ACG", + "CTG AGG", + "ACC TCGG", + "CGGCG AA", + "AGAA CA", + "CT ATCA", + "CGCG TT", + "CGG CCCG", + "CAGG TCG", + "TAT CCA", + "CCT CCAG", + "ATCG AGG", + "CAGG CCG", + "CT AATT", + "TGG ATT", + "ACG CCGG", + "TCCAG CG", + "CAAG TT", + "ACTG CA", + "TTG CGG", + "TCAG AG", + "CTCG ATG", + "CTT ATT", + "AT CCTCG", + "CC CTGCG", + "TGGG TG", + "TCCA CA", + "TAGG GG", + "ACGGG CG", + "TCTG AA", + "TTGG TT", + "CT TGGCG", + "CCG ATT", + "CCG CCGCG", + "TAAG CG", + "CTT TCT", + "TAG ATT", + "TAG CGG", + "ACC TCC", + "ACCA CA", + "TCCA TT", + "TTCG TG", + "ACG CAG", + "ATAA TG", + "ACCA TT", + "ACG ATT", + "CTT TAT", + "CAGCG AG", + "ATCA CA", + "ATG TGG", + "ATG ACA", + "ATCG TT", + "AT ATCT", + "TCC CTG", + "ACT CCG", + "TCG AGCG", + "CCAG CCG", + "AGG ATT", + "TTG CCA", + "CCCG TT", + "CT ACAG", + "CGCG AGG", + "ATAA ATT", + "TAA TAT", + "CT ATGG", + "CTGG TGG", + "TAA TAG", + "AT AGCA", + "CCGG GGG", + "CGGCG CA", + "CCTTG CG", + "CGCG CTG", + "AAG TGG", + "CT CCAGG", + "AT CCCGG", + "CCGG TGG", + "ATCG CGG", + "CTCG TT", + "ACTG AA", + "CCCG ACG", + "TTG CAG", + "CCGG CCA", + "TGAA CA", + "CCTG CTG", + "AAGG TT", + "CGG ATT", + "TCC TCGG", + "AGGG AA", + "TAA AGG", + "CT AATG", + "CC CCCGG", + "TAG CTG", + "TAG ACG", + "ATG TCA", + "AT CGGCA", + "TTG AGG", + "CCA CTG", + "TAAG GG", + "TTCG CA", + "CT CCTGG", + "CCCA TT", + "ACA AAAA", + "AGGG TG", + "TATG AA", + "CCAG CGG", + "TTTT TTTT", + "CCG CTGG", + "CCGG CAG", + "CTCA TT", + "ACC TGCG", + "TCA CGG", + "ATAA CA", + "AAG AAAA", + "AGCA CA", + "TAT CTG", + "ACT CTT", + "TCG CAG", + "ACCG CCG", + "AGCA TT", + "CCGCG CA", + "ATGGG CG", + "TAA AATT", + "CTTG CCG", + "AT CCTGG", + "CACG ACG", + "TCT CTG", + "CTT CGAG", + "TGCG AA", + "CAGG CGG", + "AAG ACA", + "TCCG TG", + "TCG ATT", + "CCCG CGG", + "TCTG AG", + "TAAG AA", + "TATT AG", + "CC CTTCG", + "AGCG CCG", + "TGCG TG", + "AGG ACA", + "ACTG AG", + "AT CTTCG", + "CTT TAG", + "CTCG AAG", + "CT ATAA", + "CCA CAG", + "CCCG TCG", + "CCA TCT", + "CGGG TCG", + "CGGCG ACG", + "CCA TCC", + "CACG TCG", + "TCGG CCG", + "CC CGGGG", + "AGG CAG", + "CC CCAGG", + "AAAG TT", + "AT CCAGG", + "CCTG TG", + "CT CTTCG", + "CGGCG TG", + "TTTT TTG", + "AAG TAA", + "AGAA TG", + "CCGG CTG", + "CCG ACGG", + "AGCG CGG", + "AATG AG", + "AACG AA", + "TAG TAA", + "CACG TG", + "CC CCTCG", + "CC CAGGG", + "TAGG AG", + "CATG TT", + "TAT ATG", + "ACC TCT", + "CC CCCT", + "CGG ACA", + "CC CTGGG", + "CGCG ATG", + "AT CCGGG", + "TTTT TAA", + "ATCA TCG", + "CC CCGGG", + "CCGCCG AG", + "TGG ACA", + "CGG ATCG", + "ATCT AA", + "ATAA TAA", + "CGCG CAG", + "CTT TCC", + "CGG CAGG", + "AAG TCA", + "ATT TCT", + "CGG CCTG", + "TAG CCA", + "TCGG TT", + "TAT CAG", + "CGCG CCA", + "CCCG AGG", + "TAA TCG", + "CGGCG CCG", + "ATG AAAA", + "CCTCC CG", + "ACGG TT", + "ATCA TCA", + "CCGCG AA", + "TCAG TT", + "ACT CTG", + "AAAT ATT", + "CACG TT", + "ACCG TT", + "ATCG CCA", + "CT CGGGG", + "CATT AA", + "CAG ACA", + "TTTG TG", + "TCCG CCG", + "ATAG TT", + "CTCA TCG", + "CAAA ATT", + "CTTG TG", + "TAA TGG", + "CT CAGCG", + "CTG ACA", + "CCAG CGCG", + "TAT AAAA", + "CCTGG GG", + "T CCAGGG", + "CTG TCA", + "CCGCG CCG", + "AAGGG CG", + "CC CGCGCG", + "TAT ACA", + "TATT TTTT", + "TCTG TT", + "ACT ATG", + "ACG ACC", + "AT CTGCG", + "CGGCG TCG", + "TTCG CCG", + "TAG CAG", + "CCTG CCG", + "CAAG TG", + "CT CCCGG", + "ATTG TG", + "CTCGG CA", + "CTG CCCG", + "ACGG CCG", + "CGGG CGCG", + "CCGG CGAG", + "CTCG CCA", + "TCT ATG", + "TGAA TG", + "TCGG CCA", + "CT CCGGG", + "ACC CGCG", + "CGG CAAG", + "AACG CA", + "AAG TAG", + "TTCG TT", + "TGGG TT", + "AAG CTT", + "CCGG ACG", + "ACCGG GG", + "CCCG CCA", + "TTG TGG", + "CTT CTCG", + "AGGG TT", + "CC CCTGG", + "AATT AG", + "TTTT TCA", + "CTT TTTG", + "ATT CTG", + "AGCG TT", + "ACAG TT", + "CACA CA", + "ATG TAA", + "TATG AG", + "TCCG TT", + "T ACGGCG", + "TACA TT", + "CCG ATCG", + "AT CTTTT", + "TTTT ATT", + "TG CAGG", + "AA ACG", + "CTG CAGG", + "TTCA CA", + "CTT CTTG", + "TAG TGG", + "TCC TCT", + "CCAGG GG", + "CC CCGAG", + "TCG CGCG", + "CAG TCA", + "CAG CGGG", + "CCAGG AG", + "CTCA CA", + "TAAG AG", + "ACA TAA", + "AA CGG", + "TACT TG", + "ATG TAG", + "CTT CCTG", + "CCGG CCGG", + "CC TTGGG", + "AT CAGCA", + "ATG CTT", + "GGG CG", + "TAT CGG", + "TACC TG", + "CCG CCTG", + "ATGG CGG", + "ATT TAG", + "TTG TCA", + "CCG ACCG", + "CT AGAA", + "CAG CCCG", + "CCG CGGG", + "ACA CGG", + "CTG CGGG", + "TTCG TCG", + "CAG ATCG", + "AATG TT", + "CTT CCAG", + "ATTTT AA", + "CTGG AGG", + "TTG TAG", + "TGG CGCG", + "TTG TAA", + "CCG TCGG", + "CTGG AAG", + "CTG ACCG", + "CCA CCAG", + "AAAA TCA", + "CATG TG", + "CCA CCGG", + "TCC TGCG", + "CCCGG CA", + "AAAA ACA", + "ACC CTT", + "ACTG TT", + "TGG CTT", + "TATT ATT", + "ACT CAG", + "CCA CTT", + "CGCG AAG", + "CGGCG CGG", + "CAGG AAG", + "TAAG TT", + "CT CCTTG", + "AATG CA", + "AACG TG", + "ACG ACGG", + "ATT CAG", + "ACC TTCG", + "TCGCG CA", + "ATT CCG", + "ACG CGCG", + "TACA TG", + "CCA TAA", + "ACTGG CG", + "TCG TAG", + "CAAA AAG", + "CCTGG AG", + "ATCT AG", + "AT AGGG", + "CCGG AGG", + "ACC TGGG", + "CTGCG CA", + "TAGG TG", + "CGGCG AGG", + "CTGG ACG", + "TCAG TG", + "CATT AG", + "CCG TAG", + "AT TGGCG", + "ACT ACT", + "TTG CTT", + "CTGG CCA", + "CCG TCC", + "CGG CCGCG", + "TAGG AA", + "AAAA ATG", + "CTCA AGG", + "CT CCACG", + "CCGGG CA", + "CCGGG AG", + "ACTT AA", + "AT CTTCA", + "ATT ACA", + "CACG ATG", + "CAG CCAG", + "TCG TCGG", + "TATG TT", + "CAG CTTG", + "CACG CTG", + "ATT TCC", + "CGGG CTG", + "ACG ATCG", + "CTGG CTG", + "CGCG CTCG", + "AT CTGGG", + "TCTGG CG", + "TACG AA", + "CAAG AAG", + "AT CCGCA", + "AT CAGGG", + "ATT CGG", + "CGGG TGG", + "AGG TAG", + "CCA TCGG", + "CC CCGCCG", + "TTCG ACG", + "ATG CCGG", + "AT CGGGG", + "TGGGG CG", + "TTCA TCA", + "ATT TCTT", + "CTCG ACA", + "TCC CTT", + "TAT CCG", + "CCCG CTG", + "TCAGG CG", + "CC CCGGCG", + "TCT CAG", + "CGG TAG", + "CCCGG AG", + "CGGG CAG", + "CCG CGGCG", + "CAGCG CA", + "ACCGG CA", + "TCCGG GG", + "ACAG TG", + "ACCG CGG", + "CCCA TCG", + "CT AAAT", + "ACCG TCG", + "TTG ACA", + "ACG AGCG", + "ATT TTTG", + "CCAGGG CG", + "CCGG TCA", + "CCA ACT", + "TATG CA", + "CAGG TGG", + "TATT TAA", + "CCT ACC", + "ATCG TCA", + "CCA ACC", + "AA CTG", + "ATGG TGG", + "AAAA AATT", + "CTCG CTG", + "CGG TCGG", + "ATT ATG", + "TCTG TG", + "ATGG CCG", + "AAAA TAT", + "CC CCACG", + "TCA TAA", + "CT AACA", + "ATCA AGG", + "CTT TCTT", + "AT CCTCA", + "CCTTG AG", + "TGTG CA", + "CT AGCG", + "CCA TAG", + "TCGGG GG", + "TGCG TT", + "ACC TAA", + "CAGG AGG", + "CT AGAG", + "TCGGCG AG", + "TGTG AG", + "TATT TTG", + "CCT ACT", + "CAGG ATG", + "TCGG CGCG", + "AAAA TTG", + "AA CCA", + "CTCA TCA", + "CTGG ATG", + "TAAG CA", + "TTGGG CG", + "ACA TCT", + "CAAA TAA", + "AGG TAA", + "CT ATAG", + "TTCA TCG", + "CGGCG ATG", + "CCCG CAG", + "CT CCCT", + "CTG CACG", + "CAGG ACG", + "CT ATCT", + "TGG TAA", + "ACGG TCG", + "CTGG GGG", + "TCA TCT", + "CCGGGG CG", + "TAGG CA", + "ACCG ACG", + "CCA CGCG", + "CT CCTCC", + "ATCG AAG", + "AT CCCT", + "CCTG CGCG", + "TACT CA", + "CTG TAA", + "ACCA TCG", + "TAT AAG", + "ATT TATT", + "TCGG TGG", + "TG CCCG", + "CTT CAAG", + "TCTT AA", + "CCTG CTCG", + "AAGG CGG", + "ATCG ATG", + "CCTG CAG", + "CTT CGGG", + "TACA CA", + "AGCG TCG", + "TAG TCA", + "CTCT AG", + "TTCG AGG", + "CC TAAG", + "CTTG ATG", + "ATCA ACA", + "CGG TGCG", + "TCGG TCG", + "CTG ACC", + "CGCG CCGG", + "CC CCCAG", + "ACCG AGG", + "TACC TT", + "TAG ACA", + "ATCA ATT", + "CTCG TGG", + "CCTCA CG", + "ACG CTT", + "CCCG ATG", + "CCTG CGG", + "ATCA CCG", + "CAG TAA", + "ATCG ACA", + "CACG AGG", + "CGGCG TT", + "AAAG TG", + "CACG CGG", + "CCG CAGG", + "ACC TTGG", + "CT AAGG", + "CCGG AAG", + "CTG TAG", + "CCAG AAG", + "CCCG AAG", + "CTTG AAG", + "AGAA ATT", + "CTGG TCA", + "ACA TCC", + "T ACCAGG", + "CT AACG", + "CCGG CGGCG", + "ACGG TGG", + "AA CCG", + "ACCG CCA", + "CT CTGCG", + "TG CGGG", + "AGG CTT", + "AGAG TT", + "CCT CTCG", + "AT CGGTG", + "CCGCCG CCG", + "ACAGG CG", + "AT CCACG", + "TCG ATCG", + "CTCA CCG", + "TGAG TT", + "TCG ACC", + "CT AGCA", + "CCAG CCA", + "ACG CTCG", + "CT CGCGCG", + "CACG AAG", + "TCT CGCG", + "CC CCCCG", + "CTT ACA", + "CAGCG TG", + "ACCAG CA", + "CAAG CTG", + "CCCAG CA", + "ATG CGCG", + "TCC CGCG", + "ACTT AG", + "ATCG TGG", + "CT CCCCG", + "CTCGG AG", + "TACC CA", + "TAT CAAA", + "ACCA TCA", + "CC TGGGCG", + "CAG TAG", + "ATCA CCA", + "TACG CA", + "CTT CACG", + "CCGG CGGG", + "CCGCG ACG", + "AT CCCCG", + "CT ATTTT", + "TGTG TG", + "ATCT CGG", + "ATTG AAG", + "CCTT AG", + "TAT AATT", + "CTT CTGG", + "CCTCA AG", + "CTG ATGG", + "TCC TTGG", + "TAA TATT", + "TGCG CCG", + "CCGG ATG", + "ACGG CCA", + "ACC TGCA", + "CTT CAAA", + "CCTT AA", + "CGGG ACG", + "TAA ATAA", + "ATTG ATG", + "CATG CCG", + "CTCG TCA", + "CTTG TCG", + "TTG AAAA", + "CCA AAAA", + "TG ATGG", + "CC CGGGCG", + "CCTCG AA", + "ACA ACT", + "AGCG CCA", + "TCC TTCG", + "TGG TAG", + "CTT CAGG", + "CGGG GGG", + "TCCG CCA", + "CCAGG AA", + "CGGCG CTG", + "TAA ACG", + "CCTT CGG", + "AAG AAGG", + "CAG CTGG", + "CCG ATGG", + "ATAT ATT", + "ACC TTCA", + "CCT CTGG", + "CCAG TCG", + "CTT CATG", + "CAAA ACA", + "CC CCTTG", + "TACG TG", + "CAGG TTG", + "TAA CCA", + "AGCG ACG", + "T ACCGCG", + "TAA CTT", + "CGCG TGG", + "ACTG TG", + "AGCG AGG", + "CTTG CGG", + "ATTTT AG", + "CTT CCGG", + "CGGG AAG", + "CAG CAAG", + "CTG TTCG", + "TCA AAAA", + "CTT CCCG", + "CTCT AA", + "TAT TGAA", + "CCGCG TCG", + "TCCG CGG", + "CGGGG AG", + "TAG AAAA", + "ACGG CGCG", + "ATGG TCG", + "ACGCG CA", + "CCG TCT", + "CTG AAGG", + "CCGGG AA", + "TGG CCGG", + "CAG CATG", + "TCCA TCG", + "CTGGG AG", + "AGCA TCG", + "CTT ATG", + "ATAA AAG", + "TAGG TT", + "ATT AAAA", + "ACG TAG", + "CC CTTCA", + "CT AGTT", + "CT CTTCA", + "CTTG TTG", + "TGGG CGG", + "ACA CTG", + "CGGG ATG", + "CGGG CGAG", + "CTCG CCGG", + "CC CCTCC", + "CTTGG GG", + "CGGCA TCG", + "TTTT CTT", + "CT CCTCA", + "TCA TCC", + "TGCG CGG", + "TTCG CGG", + "CT CCCAG", + "TCGCG AA", + "CCCA CCA", + "CT CTTTT", + "CAAG CCG", + "CCTG AAG", + "CCTCG ACG", + "ACCA CCA", + "CAAA ATG", + "TATT TCA", + "ATCA AAG", + "CAGG CTG", + "ATCA TGG", + "CCAG TTG", + "CCCA TCA", + "CCTCG TCG", + "TCT TGAA", + "TCCA TCA", + "ACGGCG AG", + "ACG CTGG", + "ACC TCCG", + "CATG ATG", + "CCG CACG", + "TG ACCG", + "AT CCTTG", + "TCC TGCA", + "ACA TAG", + "TTGG TGG", + "CCAG ATG", + "CAG CCTG", + "ACC TAT", + "ACC CGCA", + "ATTG ATT", + "AAAA AGG", + "CCCG TGG", + "AAGG TCG", + "CGGG CCA", + "ATCA ACG", + "TCTT AG", + "ATTG TTG", + "TGTG TGTG", + "ATAA TTTT", + "ACGGG GG", + "CCAG CTG", + "CTTG CTG", + "AGGG CGG", + "CATG AAG", + "TTGG CGG", + "AGGGG CG", + "TATG TG", + "TCC TCCG", + "CTCA ACG", + "ATT TTCA", + "CACA CACA", + "AGG CGCG", + "TT CTCG", + "ACC CCGG", + "TCC TGGG", + "AAGG CCG", + "TGTT AA", + "TG AGCG", + "CCCG CCGG", + "TACT AA", + "CAGG CCA", + "TTTT TGG", + "ACC TGAA", + "TCC TCCA", + "CTGG CAG", + "CTTG AGG", + "TTG CCGG", + "CC CCCTG", + "CTT TGCG", + "CC TAGG", + "ACG ACCG", + "CAGG GGG", + "CT CTGGG", + "ATAG TG", + "ATG ATGG", + "TAT AGG", + "CCG ACT", + "ACG ATGG", + "CAAA TCA", + "ACC TTTT", + "TCAG CAG", + "CGGG AGG", + "CC TTGGCG", + "CAAA TTG", + "CCGG CTCG", + "TCGG TCA", + "TCCAG CA", + "CTCGG TG", + "AAGGG GG", + "TGGCG AA", + "ACA CAG", + "CCTG ATG", + "TCCGG CA", + "TGGCG CA", + "CTGG TTG", + "CCGCG TG", + "CTT TTGG", + "TCC TTCA", + "TCCG TCG", + "ACTGG GG", + "ACA TTTT", + "ACGG CAG", + "CCGG CCAG", + "AGAA AAG", + "CAAG CAG", + "ATT TGAA", + "CT CCGAG", + "CT CAGCA", + "AT CGCGCG", + "TGTG TT", + "CGGG TTG", + "AT AAAAAA", + "TCCA CCA", + "T ACCGGG", + "ACT TGAA", + "CGG TCT", + "CCGCG TT", + "CGCG AGCG", + "TAG CTT", + "CCCT TGG", + "CCTGG AA", + "AAGG TGG", + "TCC TAA", + "TCTT TTG", + "CGGCG AAG", + "AAAA TTTT", + "ATT ACG", + "TCGG CAG", + "CC CAGGCG", + "TCAG CGG", + "ATG ATCG", + "CTT TTCG", + "TCA CTG", + "AT ACCGG", + "CT ATAT", + "TG TAA", + "CCTCG CCG", + "ACC TCTT", + "CC TCCGCG", + "TGTT AG", + "CGGCGG AG", + "TCTGG GG", + "CTGGG CA", + "TCG ACGG", + "AGGGG GG", + "AATT TCA", + "ATGG AAG", + "CTG CTTG", + "CTCG AGCG", + "CCGCG CGG", + "TGG CGAG", + "TTCG CCA", + "AT CCAAA", + "AAGG AAG", + "CCGG TTG", + "AGTT AA", + "CT CCT", + "TCTT CTT", + "ACG CCCG", + "AACG TT", + "ATGG CCA", + "CCGG CACG", + "CTCA ACA", + "TCC TGAA", + "CCAG CAGG", + "CATG TCG", + "CTCA CCA", + "CTGG CGCG", + "AATG TG", + "AAGG AGG", + "ATTG CCG", + "CCTT CTT", + "TCC TTTT", + "CCCA CCG", + "TCTCG AG", + "CCAG CTCG", + "ACC CGGG", + "CCGCG CTG", + "AAAA TGG", + "AGCA TCA", + "AATT TTG", + "CCTT CAG", + "CACG CCA", + "ACCG TCA", + "CC CTTTT", + "TACT AG", + "CTT ACG", + "AATT TAA", + "ATT AAG", + "TTTT TAT", + "ATCT TGG", + "CGAG TT", + "CTT TATT", + "AAAA TATT", + "CCG TTCG", + "CT CAGGG", + "AAATT AA", + "CCCA AGG", + "CTCG TTG", + "ACC TCCA", + "CT ACCGG", + "ATCA ATG", + "ACGG TCA", + "CGG CATG", + "CCCT AG", + "CAGG TCA", + "CGG TAA", + "CCCT AA", + "CCTT CCA", + "CCAG ACG", + "TCT CCGG", + "CT CCGCCG", + "TCT ACT", + "TTTG TTG", + "CTT TCCG", + "CAAG ATG", + "CT CCGCA", + "TGGGG GG", + "AAAA ATAA", + "CAAA TCG", + "CTT TGAA", + "TCGGG CA", + "CCAG CACG", + "CCTG CCA", + "TCC CCGG", + "TACAG CG", + "CCG TCCG", + "TGAG TG", + "CTCA TGG", + "ACCG TGG", + "ATT TTGG", + "AAG CGCG", + "CAGG CAG", + "ATGG AGG", + "CAAA AGG", + "TCC TCTT", + "TCA TAG", + "CCTG ACG", + "TACTT CG", + "CT CCGGCG", + "TCG CCCG", + "CCTT TTG", + "CCCTG CA", + "CCCGG TG", + "AAAG AAG", + "ACCA AGG", + "CAAA TGG", + "CTG CCAG", + "CATT TTG", + "CAGCG AA", + "CC CCT", + "CCCA TGG", + "AAGG CCA", + "AGTT AG", + "CGG CTTG", + "CGGGGG CG", + "ACAG CAG", + "CTG CGAG", + "AGAG TG", + "CTCG ACC", + "AT CGGCGG", + "AT CCCAG", + "TAA AAAT", + "CTG ACGG", + "TTTG ATG", + "TT CCTG", + "CCG AGCA", + "CGG AGCG", + "TTTG AAG", + "CGCG TTG", + "CT AGGG", + "CTCA AAG", + "ACA ACC", + "CCG TGCG", + "CTT TCTG", + "CCACG AA", + "CCCGG AA", + "TCG AGCA", + "ACA TAT", + "CT ACGCG", + "CAG AAAA", + "ACG TCGG", + "ATGG GGG", + "TTTG ATT", + "CTT CGGCG", + "CTTG CCA", + "ACA TCGG", + "CCG AAGG", + "TCA TCGG", + "CCG AACG", + "TCT TGCG", + "AGG CCGG", + "CTT TTCA", + "CGCG ATCG", + "CTT TCCA", + "TAG TTTT", + "TT CACG", + "ACC CTGG", + "ACG ACT", + "ATCT CCA", + "CAG TTCG", + "ATAA TTG", + "CCTG TCG", + "ATCA TTG", + "CTG AGCG", + "AT CCGGCG", + "ACT AAG", + "TT CGGG", + "CCA TCCG", + "CGCG CGAG", + "AATT ATT", + "CT CCCC", + "ACTT TTG", + "ATGG TCA", + "CATG CTG", + "TAA CTG", + "CCTG TTG", + "AAGG TCA", + "CCAG TGG", + "CTT AAG", + "CTTG ACG", + "ATAA TCA", + "TG ACGG", + "CCGG CCCG", + "AT ACAAA", + "AAATT CG", + "CCA TCAG", + "CCAGG CA", + "TGCT AG", + "CCG AGGG", + "CGG ACGG", + "TCT AAAA", + "CTTTT AA", + "CCTT TGG", + "CAGGG CA", + "CACG TTG", + "ACT AAAA", + "AGCG TGG", + "ATG TTTT", + "ATATT AA", + "CAAG ACG", + "CCG ACCA", + "ACC CAGG", + "AGGCG CA", + "CAAG CGG", + "TGGG TGG", + "CTGG CCGG", + "ACCGG AG", + "CCG TAA", + "ATATT CG", + "TCTT TCA", + "TACG TT", + "ACC TGCTG", + "ACT CGCG", + "CCA TTTT", + "TTCA AGG", + "TTCG ATG", + "CAG CAGCG", + "CC CTGGCG", + "CCCG ACA", + "CCGCCG CA", + "TAAG TG", + "CGG TCC", + "CCA TAT", + "ATAT ATAT", + "CCAG CCGG", + "TCCG ACG", + "CCTTG AA", + "TCG TCC", + "CTT TCAG", + "ATTG CTG", + "TCGG CGGCG", + "TTGG GGG", + "CT ACCAG", + "CCCG TCA", + "AT CCCCA", + "TCG ATGG", + "TTCA ACA", + "AT TGGGG", + "CGGCGG CGG", + "ACCG ATG", + "ACCG AAG", + "TTCG TCA", + "TG CACG", + "CTCG CAG", + "TCT AAG", + "CATG ACG", + "AAAA TAG", + "CC CCTCA", + "ACC TTTG", + "AGCA AGG", + "CT CCCTG", + "ACC TGTT", + "CAGG TAG", + "CC CCAAG", + "CCGCG ATG", + "TG AAGG", + "TGAA ATT", + "ATAA TAT", + "TCT CCAG", + "CGGCG TGG", + "ATAA ATG", + "ACGCG AA", + "CCGCG CTCG", + "TCAGG GG", + "CCGCG AGG", + "CCA CGAG", + "CCG CAAG", + "CT ACTGG", + "CCTG CTGG", + "TTCA ATT", + "TAA CAG", + "TAA AAAG", + "ATCA CGG", + "AT CCGAA", + "TCCGG AG", + "CCCGCG AG", + "ACCA ACA", + "CTG AAAA", + "TT CCAG", + "TATT TAT", + "TCT CGGG", + "TAA AGAA", + "AAG ATCG", + "TCC CGAG", + "CTT TCGG", + "CCA CCCG", + "TAA ACT", + "CCT CAGG", + "AAG CCGG", + "ATG AAGG", + "CCCAG AG", + "CCGGG TG", + "CAGGG AG", + "CGCG ACA", + "ATG CTGG", + "TAA TCT", + "AAG TTTT", + "TCG ACCG", + "TCTG CTG", + "AACG CCG", + "AT ACCAG", + "T ACTGGG", + "CCGG ATCG", + "ACC CTCG", + "ATTG CCA", + "AGGCG AA", + "CTTGG AG", + "ACTT TCA", + "TTG TTTT", + "CCA TGCG", + "TGG CGGG", + "ACCA CCG", + "TAT ACG", + "CGCG CCCG", + "CAGCG CCG", + "ACA AGAA", + "TCC CGGG", + "ACA CTT", + "CCAGG TG", + "CTCG ACGG", + "TCTT TTTT", + "CACA TCG", + "ATCG CTG", + "TTG CGCG", + "CTCT TGG", + "TTGG CCG", + "CGG ATGG", + "CAG ATGG", + "TAT TGTT", + "TTCG TGG", + "TCC CGCA", + "CCT ACGG", + "TCG CTT", + "TCGG CCAG", + "ACCA TGG", + "AAAA AAAT", + "ATCTG CA", + "CTG CTCA", + "TCT CCTG", + "CATG TTG", + "CTCT CGG", + "CCGG CTT", + "TCCG AGG", + "CTTCG AA", + "CT CCAAG", + "TCCAG AA", + "CCTT CGCG", + "ACC TGCT", + "TTCA TGG", + "CTG AACG", + "ATG TAT", + "AACA TCA", + "TCAGG AG", + "ACC TAG", + "CAG CAAA", + "ACGGG CA", + "AGAG AGAG", + "TCT TGAG", + "TCTT CCA", + "CGGG CCGG", + "CTCG ACCG", + "CAG CGGCG", + "TCGG CTG", + "CC CCAAA", + "CCCA CGG", + "TGATG AA", + "ATT TCCA", + "ACTGG AG", + "CCCAG AA", + "TGCTG CA", + "TTGG TCG", + "CCGAG CGCG", + "TTGG CCA", + "CTCG ATCG", + "ATAA ACA", + "CACG CAG", + "TTTTG AA", + "ACC CGAG", + "CT ATTGG", + "CATCA AG", + "AAAA TCG", + "TT CTGG", + "TCA ACT", + "AGCA CCA", + "CCGG CAAG", + "CCTGG CA", + "ACCAG AA", + "ACAGG GG", + "TCTGG AG", + "TGCG CCA", + "TCC CAGG", + "TCTT CGG", + "TTCG ACA", + "CTTG CAG", + "CTT CATT", + "TT CCCG", + "CT CTTTG", + "AGCA CGG", + "CCCA ACG", + "ATCGG AG", + "CCGG CTGG", + "ATATT CA", + "ATCG TTG", + "CAAG TTG", + "ACCG ACA", + "ATGG ATG", + "AAG AAAG", + "TACTT TT", + "ATGG ATT", + "TCAGG AA", + "CACG TGG", + "AAAA AGAA", + "ACTCG AG", + "TCGG AGG", + "TCTT TGG", + "TCTT TAA", + "CCAG AGG", + "TCG CTCG", + "TTGG TCA", + "AT CCGAG", + "ACAG CGG", + "TCG TCT", + "CCA AGCG", + "CCG CCTCG", + "CCCCG CA", + "ACGG CAAG", + "CT CCATG", + "CAAA ACG", + "TCG CGGG", + "TTTCA AA", + "TGCCG CA", + "AAATT CA", + "AGCA TGG", + "ATGG ACG", + "CCGCCG AA", + "CCG CCCA", + "CTG CCTG", + "ACTGG AA", + "TT CTTG", + "CTGCG AA", + "TG TTCG", + "CCACG CA", + "CAG AAGG", + "TT CCGG", + "AAAA ACT", + "CTG TCGG", + "AGGG CGAG", + "ATG CTCG", + "ATG AGCG", + "TCG CTGG", + "AT ATGAA", + "CCCG CTCG", + "TAA CGG", + "TCAG CCA", + "CCGG CCTG", + "TCC TTTG", + "TCGGG AG", + "TG ACC", + "CCG ATCA", + "AAG TAT", + "ATAT TGG", + "TGCCG AA", + "ATG ACGG", + "CTCGG CGG", + "CATT TCA", + "ATT CAAA", + "ATG ACC", + "CTCT CTCT", + "CCCG TTG", + "CGGG TCA", + "CGGCG CAG", + "ATGG CAG", + "ACAGG AG", + "TGATG AG", + "CGCG CTGG", + "CAAG CCA", + "ACA AATT", + "ACCA CGG", + "TCG AGGG", + "CC CCATG", + "CT CTGCA", + "AGG TCGG", + "ACCA AAG", + "CGCG TCA", + "CT CGGGCG", + "ACC TGAT", + "CCG CCGGG", + "ATCG ATT", + "TCTCG AA", + "CCTT CTG", + "AT CCCC", + "CAAA CCA", + "CT CCAAA", + "TATGG CG", + "TTGG AAG", + "CAG TAT", + "CT ATATT", + "TCTGG AA", + "CCCTG AG", + "AGCA ACA", + "CCCGG CGG", + "TCG AAGG", + "ATGGG CA", + "TTCA CCA", + "TTG CTGG", + "ATG AATT", + "AGG AGCG", + "CGGG CGGG", + "AT AGGCG", + "TCCA TGG", + "ACTT CTT", + "ATTG CGG", + "CGGGG CA", + "ATG TCGG", + "TTTT CCA", + "ACG AAGG", + "TTTT TCT", + "TCCG CTG", + "ACCGG AA", + "AGCA CCG", + "CCCA AAG", + "AT CCGCCG", + "TAA CCG", + "TTG ATCG", + "CATG CGG", + "ACA AAAG", + "AGG TCT", + "AAAA AAAG", + "CCTCC TG", + "CAAG ATT", + "CCA CCTG", + "TACTG CG", + "TAT CATT", + "CT ATCTG", + "ACT TGCG", + "CCAG CCCG", + "ATTG CAG", + "ACT CAAA", + "ACCAGG CG", + "ATTGG AA", + "ACCG CTG", + "AAGCG AA", + "ACTT TGG", + "ATTTT TAA", + "TAT ATAA", + "TATT TGG", + "CCTT TCA", + "CCG CTTG", + "ATTG AGG", + "CTT TGGG", + "ACG CGGG", + "AGCG TCA", + "CATG CAG", + "ATCAG AA", + "CCT CCAGG", + "AT ACTGG", + "TTGG AGG", + "TCC CTGG", + "CACG CCGG", + "AAG AATT", + "TTGG TTG", + "CT ACGAG", + "ACCG CGAG", + "AT CCAAG", + "CCAG CGCA", + "ACAGG AA", + "ACCCG AA", + "CCTT TCG", + "CTCA ATG", + "CCCCG AA", + "AAG CTCG", + "ACGGG AG", + "CTCA CGG", + "TGAT CGG", + "TTTT TTTG", + "AGCA ATT", + "TCT TGTT", + "ATTGG AG", + "AAAA CCA", + "CGGCG CCGG", + "ATTCG AA", + "CTCA TTG", + "AT AAGAA", + "AGAA ACA", + "ACTG CTG", + "TT CATG", + "ACT CCGG", + "CCTG TGG", + "ACC CAAA", + "ACG TCC", + "CTGCG TG", + "CCT CGGGG", + "TTCA AAG", + "CAAG TCG", + "ACCGGG CG", + "ATCA TCT", + "AGCA AAG", + "AGCG AAG", + "ATG ACCG", + "CAGG ACA", + "ACCAG AG", + "TCA CCGG", + "CC CTTTG", + "CTCT CCA", + "CCGGG CGG", + "CTG TAT", + "ATT TCGG", + "CGGG ATCG", + "AGGG TGG", + "TCGGG AA", + "CGGG CTCG", + "ATTTT TTG", + "ATT TCAG", + "ATGGG AG", + "CCGCG CAG", + "TCG TAA", + "ACCA ACG", + "CCCT CCA", + "CT CCCCA", + "CAAG TGG", + "TCCAG AG", + "CCGGCG AA", + "CAAG AGG", + "TTCA ACG", + "TACA TCA", + "ACT ACC", + "CCCG CCCG", + "ATGG CTG", + "ACGG CTG", + "CGCG CGCA", + "CCT ACCG", + "TT CAGG", + "ATTG TAA", + "CCTCG CA", + "TTGG ATT", + "CGGCG AGCG", + "CCTCC TCG", + "TCAG CCG", + "ACGG AGG", + "AAGG ACG", + "CC TAAAA", + "TGCG TCG", + "AGCA ACG", + "TGG TCGG", + "CC TCTTCG", + "TCCG CAG", + "CCGAG CAG", + "CACG ACA", + "ATTG TCA", + "AGAA ATG", + "TTCA CCG", + "ACCA ATT", + "ACGG ACG", + "CTTCG CA", + "TTTG CCA", + "CTT TGAG", + "ATAA TATT", + "AAG CTGG", + "CC TATCG", + "CCTGG TG", + "ATCG AGCG", + "TCGAG CAG", + "CCGG ACA", + "TTTT TCG", + "CCCTG AA", + "ACCG CAG", + "TCCA CCG", + "AACG CGG", + "TT TAG", + "ACT ACTT", + "AACA ACA", + "AACG TCG", + "CCCA ACA", + "ATCA AAAA", + "CTAA ATT", + "CCGCA TCG", + "CAGG ATT", + "CGGCG CCA", + "CCCA TTG", + "TTTT TATT", + "ATTG TCG", + "TCTT CAG", + "CAGG CGCG", + "AAGGG CA", + "TTTT TAG", + "ATG AAAG", + "ATCT CCG", + "AAAT AAAA", + "CTTGG CA", + "ACC TCGCG", + "TCAG CGCG", + "ACTT CGG", + "ACTT TAA", + "TGGG CCG", + "CT CCGTG", + "CT CCAGCG", + "CTG TCC", + "AGAA AGG", + "TCT CGGCG", + "ATGG TTG", + "CTTG ATT", + "TCCG CGAG", + "AAGG ATT", + "ATCG CCGG", + "AACA TCG", + "ACTCG AA", + "CCAG CTT", + "TCA CAG", + "ATTG ACG", + "AGCG CAG", + "TT ACA", + "ACCA TTG", + "T ACAGGG", + "CCGGCG CA", + "TTCA TTG", + "TGG CTGG", + "TT ACG", + "TTCG AAG", + "TT ATG", + "ACGG CGGCG", + "TGCG ACG", + "CCTG CCGG", + "TTTG CCG", + "ATCA TAA", + "CCTT CCG", + "TT TCCG", + "ACT CCAG", + "ATAA AGG", + "TGG TCT", + "TTAA TAA", + "TGCG CTG", + "CCGCG CCA", + "CCGGCG CCG", + "CGGGG AA", + "ATCG CAG", + "TCCGG AA", + "CCGCG AAG", + "CCGGG TCG", + "AGCG ATG", + "CCTCG AGG", + "ATGCG AA", + "AAAA CTT", + "ATTTT ATT", + "TGCG CAG", + "CTTTT AG", + "TTTG TAA", + "TCGG CGGG", + "CGGCA AGG", + "TCC TAT", + "CTGG ATT", + "CCGCG CCGG", + "TCACG AA", + "TT CAAG", + "AAAA ACG", + "TCT TGGG", + "AACG ACG", + "CTGG ACA", + "TCGAG CGCG", + "CTCT ACG", + "AT ACAGG", + "TG CTTG", + "AAAT CCA", + "TCT CCTT", + "CCTCA AA", + "CAAA TAT", + "TTTG CTG", + "CCT ACTT", + "TGCTG AA", + "TCC TGTT", + "CCTCC CA", + "CGCG CACG", + "CCTG ATCG", + "CAGCG CGG", + "CCAG CGAG", + "TCGG ACG", + "AGCG CTG", + "ACT TGTT", + "CTCT CCG", + "AACA ATT", + "TCA TTTT", + "CT ACCTG", + "TGGG AGG", + "ACAG CCA", + "CCGG ATT", + "TATT TATT", + "TACG ACG", + "TCCAGG CG", + "ACT AGG", + "CTTG TGG", + "CTT TGTT", + "TCGCG CCG", + "CTT CTTCG", + "CAG ACC", + "AT CCCTG", + "CTCG TAG", + "TTG ATGG", + "CTT CCTT", + "CTG ACCA", + "CTCG TCGG", + "ATG CGCA", + "ATAA TAG", + "CTCA ATT", + "TCCG TCA", + "ATG CCCG", + "ATAG AAG", + "ATGGG AA", + "TCT CAAA", + "CACA TCA", + "TAA TGAA", + "ACGGG AA", + "TCTG CGG", + "ACAG AAG", + "TTTCA AG", + "TGGG CAG", + "TCCG TGG", + "CGGCG TTG", + "ATCTG AA", + "AT CCATG", + "TCTT CTG", + "TG TCGG", + "TCCA TTG", + "AT ACGCG", + "TACG CCG", + "CCACG CCG", + "CTT TGCA", + "CTCG ATT", + "CTCG CCCG", + "TAT CGAG", + "AAGG ACA", + "AAATT AG", + "CCTG CCCG", + "AAAT TGG", + "CTT AAAA", + "ACTT CCA", + "CGG ACCG", + "AAAG ATT", + "CGGG CGGCG", + "TCT TGCCG", + "CTG CATG", + "CCGGG CCG", + "CAG ACCG", + "TCCGGG CG", + "CCGG CAGG", + "TAA AATG", + "AACG CCA", + "AGAA TTG", + "TGGG CCA", + "ATG TCC", + "ATGG ACA", + "CTGGGG CG", + "ACT TGAG", + "AAGGG AG", + "AGAA TCA", + "ACG ATCA", + "ACTT TTTT", + "CTGG TAG", + "CTGGG AA", + "ATG CAGG", + "TACC TGG", + "ATTG TGG", + "CTGGG TG", + "CT ATCAG", + "TGCTG AG", + "TCCA AGG", + "CGGG CACG", + "CATT ATT", + "AGAA TGG", + "CGG TTCG", + "CTG CAAG", + "ATCGG AA", + "TCTG CCA", + "ATG TCT", + "CGG CAGCG", + "ATCT ATT", + "CGCG ACCG", + "CTTCG TG", + "CCGAG TT", + "TCCG AAG", + "ATATT TG", + "TGGG TCG", + "AT CCCTT", + "CCGGG TT", + "ACGG AAG", + "CTG ATCA", + "AGGG CCG", + "AAAA AATG", + "CCAGG TCG", + "TCT CCCG", + "ACT CCTG", + "TAG TAT", + "CCCGG CCG", + "CTT TGTG", + "CACG TCA", + "CCAG ATCG", + "ACTG AAG", + "CGCG CAGG", + "ACC TGAG", + "ACC TCAG", + "CGGTG ACG", + "CCCT CCG", + "CAAA CAG", + "TCTG CAG", + "CGGCG CTGG", + "CT ATCTT", + "AGG CGAG", + "ATG CGGG", + "AT CCTCC", + "ATTG AAAA", + "ATG ACT", + "CC TCTTG", + "TGGG AAG", + "ATG AACG", + "CTG AAAG", + "TCC TAG", + "ACG TAA", + "CT ACAAG", + "CT ACTCG", + "ATAA TGG", + "TCTG TTG", + "AGG CGGG", + "CTT CCTCG", + "CTG CAAA", + "TCTG CCG", + "CCA ACGG", + "TCCA CGG", + "CTG TTTT", + "CGGCG CTCG", + "TCG CGAG", + "CGCG ACGG", + "TAT ACT", + "TCCCG AA", + "CCTTCG AG", + "TCCA AAG", + "TCCA ACA", + "TTTTG AG", + "ACC CACG", + "CCAG ATT", + "AAAT ACA", + "TGGGG AG", + "TT TCTT", + "AGAA TAA", + "TCT TGCA", + "AGG AAGG", + "AAGGG AA", + "TACCA CG", + "CTTG TAG", + "CATT TCG", + "AT ACATT", + "TG CCAG", + "CAG AAAG", + "TACA ACA", + "CAAA TAG", + "AATG AAG", + "AT ATGGG", + "TGTT TTG", + "CGG CGGCA", + "TCC TGCT", + "ATCT CTT", + "TCT AGG", + "TGGG ACG", + "CGCG CGGG", + "T ACGGGG", + "CCTGG CCG", + "CGGCG ATCG", + "TTCG ATT", + "TTGG CAG", + "ACT CGGG", + "TCGGGG CG", + "CATG TGG", + "CT ACCCG", + "CATT TGG", + "CTTCG TCG", + "CTAA TAA", + "AGCG ACA", + "TCCA ATT", + "CCTTG CA", + "TCGG CCGG", + "TGAA AAG", + "ACAG CCG", + "CCGAG CGG", + "AGG AAAA", + "CTGCG CCG", + "CT ACGGG", + "TTGCG AA", + "TCC CAAA", + "TCC CTCG", + "ATTGG CA", + "ATAG ATT", + "ACGG CACG", + "CTT ACT", + "CCGG CCGCG", + "CC CCAGCG", + "CTCGG AA", + "ACC TGCCG", + "CCAG CCAG", + "CATCG AA", + "AAGG TTG", + "CAG CACA", + "ACC CCCG", + "CATG CCA", + "TTTT TCTT", + "CCTCG ATG", + "ACC TGGCG", + "TTGG CTG", + "TCAG AAG", + "CTTGG AA", + "CATCA AA", + "TTTG TCA", + "CCGG TGCG", + "AT ACTCG", + "AACA CCA", + "ACG AACG", + "ACCG CGCG", + "AGG ATCG", + "AAGG ATG", + "CGGCG ACA", + "ACC TACA", + "AT ATGTT", + "TTGG TAA", + "CCTGG TCG", + "TTGGG AG", + "CCTCG CGG", + "TCTG AAG", + "ATTG ACA", + "CATT TAA", + "TCCG ATG", + "TGGG CGAG", + "TAT CGCG", + "AGGGG AG", + "ATAT CCA", + "CCAG CGGG", + "TCCG CGCG", + "ACC TACG", + "AAGG CAG", + "TTGG ATG", + "ATTTT TCA", + "CGGCA ACG", + "CCCT CGCG", + "CTTCG CCG", + "AT CCT", + "ATCT ACA", + "TCC TCAG", + "CGG AACG", + "TTCA ATG", + "CGGTG CCG", + "CCTG CACG", + "CAAG ACA", + "CT CCGAA", + "TCG ATCA", + "TT TCGG", + "CCGAG CTG", + "AAATT TG", + "CT ACACG", + "AGGG AGG", + "ACCA ATG", + "CCTG CAGG", + "CACA ACA", + "TCT TGTG", + "ACC CGGCG", + "TTCG TTG", + "CAGGG AA", + "CTTCG ACG", + "CAGCG TCG", + "TCC TCTG", + "CATG AGG", + "CGCA TCG", + "TCC TGAG", + "ACTG TTG", + "TCCG ACA", + "CAG AGCG", + "TGCA TCA", + "AT CCCGCG", + "TGCG TGG", + "TGCA TCG", + "CCGG TAG", + "AT CCGTG", + "ATCA ACT", + "TCC TGAT", + "CGGG CTGG", + "CCCG AGCG", + "CCAGG CCG", + "CCTCCA CG", + "TAA TTAA", + "ATAA ATAA", + "CTG TCT", + "CACG ATCG", + "CCGCG ATCG", + "TGCT TGG", + "ACCG TTG", + "CA CAG", + "TTTG CAG", + "CGG TGAG", + "AGGCG CTG", + "AGTT TTG", + "TCGCG TT", + "TAT AAAG", + "CGG TCAG", + "AAAT CTT", + "AATG ATG", + "CCTG ATT", + "ACTG CCG", + "TAT CAAG", + "CCA TCCA", + "AT AAGTT", + "CTG ACT", + "ATCAG AG", + "CGGCA TCA", + "TACG TCG", + "CAGGG TG", + "TGGG TCA", + "CGGGG TG", + "CTTG TCA", + "AAAA TCT", + "ATT AATT", + "ATATT AG", + "CT ACAAA", + "CCGAG CCG", + "TAT ATTG", + "TATT TCT", + "CAGG CCGG", + "AGG ACGG", + "CCGCG CTGG", + "TTTG TGG", + "ACTG CCA", + "AGGCG TT", + "TCG AACG", + "TCGG CTT", + "CGGCG TCA", + "CGGCG ACGG", + "CCGCCG CCA", + "ACC TGTG", + "CCAG TAG", + "TGGCG TT", + "TTTT CAG", + "AGCA TTG", + "ACG AGGG", + "CACG CTCG", + "ATCGCG AG", + "ACTG CGG", + "TGCG AGG", + "CAGCG CCA", + "ACTGG CA", + "TCAG TTG", + "ACC TCTG", + "CCTG AGG", + "TGGCG ATG", + "CCTCG TG", + "CAG AACG", + "CTG TTGG", + "TAA AACA", + "TAA TTTG", + "TCTT TCG", + "CCGGCG TG", + "CTCT ACA", + "ATT TTCG", + "CT ATCGG", + "TGGG TTG", + "TGCT CGCG", + "CCGCCG ACG", + "CCGCCG TCG", + "ATT CGCG", + "CCT CCGGG", + "CGG TCCG", + "TCGG CCTG", + "TATT CCA", + "CCGCG CCCG", + "CTT AGG", + "TTTT TTAA", + "TT TTGG", + "AAAA AAATT", + "TAT TGCA", + "TCC CACG", + "TTGGG CA", + "CCGGCG ACG", + "TAG CCGG", + "TATT TTTG", + "CTTG CCGG", + "TAG AATT", + "TACA ATT", + "AAG CGCA", + "TGAT CGCG", + "TAT CTGG", + "AAG ATGG", + "CCT ACAG", + "CGAG CGCG", + "TCGCG CTG", + "CCTT CTCG", + "ACT CAAG", + "ACT TGCA", + "TGG ATCG", + "CCACG TCG", + "AGCA ATG", + "ATAT CTT", + "TACA TCG", + "CGAG TG", + "AAG AACG", + "TGGG CGCG", + "ACA TCTT", + "AT ACAAG", + "AACA AGG", + "TGAT ATT", + "ACA CCGG", + "ACC CATG", + "TGGCG ACG", + "CGG CCTCG", + "TCGG CAAG", + "CTG TTTG", + "TCGCG ACG", + "TTGGG AA", + "CCCA ATG", + "CCTG CTT", + "TTG AGCG", + "AT ACCCG", + "TTTTG TT", + "TCC TGCTG", + "ACTT CAG", + "CTG TCCG", + "CCCG ACGG", + "AAAT ATG", + "ATTG CTT", + "CCA AGGG", + "CTCGG CCG", + "CACA AGG", + "TAG AGCG", + "TCT CTTG", + "T AGGGCG", + "CCTG CGCA", + "TAT CTTG", + "CTAG TG", + "TAA AAATT", + "ACC CAAG", + "CCA AAAG", + "ACGG CTT", + "CCT ATGG", + "ATT TCCG", + "CCA TCTT", + "CTAA AAG", + "CAG CTCA", + "TTTG AGG", + "TTG AAGG", + "TGG TGCG", + "CT ATTAA", + "CGGG CAGG", + "CCCC CCCC", + "CCCG CCAG", + "CGG TGGG", + "CCCGG TCG", + "CCA TCTG", + "ACG ACCA", + "TACTT CA", + "ACT TGGG", + "ATAG ATG", + "ACG TCT", + "CCTCC TT", + "TTTG TCG", + "ATCCA CA", + "CCA TGAA", + "AGAG AAG", + "AAAA CAG", + "ATT TGTT", + "CCA ACCG", + "ATCT CGCG", + "TGGCG TG", + "TTG CTCG", + "CGGCA CCG", + "TAA TCTT", + "TGGGG CA", + "TCGCG CAG", + "TCGCG CTCG", + "CT ATTCG", + "TCTGG CA", + "CCT ACCA", + "TATT CTT", + "AGG AGGG", + "AGAA TCG", + "TCC CCCG", + "AAG AGCG", + "CCAG TCA", + "ACA AATG", + "CTG TGCG", + "ACTG ATG", + "ATAG TTG", + "CGG CCGGG", + "CT CCCGCG", + "TG CTCA", + "CTCC TCGG", + "ACC CTTG", + "CCACG ACG", + "ATT ACT", + "TT TCTG", + "TCT CAAG", + "CTCGCG CA", + "CGG CAAA", + "AACA AAG", + "ACACG AA", + "CTG ATTG", + "TCC CATG", + "AGAA ACG", + "AATT TGG", + "TCGG CTCG", + "CTG CCCA", + "CACA AAG", + "CGGCG CGGG", + "ATGG CTT", + "CCCTCG AG", + "AT ACGGG", + "CGG TGAA", + "AGTT TCA", + "ACTG CAG", + "AGGG CAG", + "TACCA AA", + "TATT TAG", + "TT TCCA", + "CTG CTCGG", + "CCCG CTGG", + "ATT TCTG", + "ACAG TTG", + "CCCG CCGCG", + "GGG AG", + "CCG CCTT", + "AT ATGCG", + "ACA ACTT", + "TCGGCG AA", + "CGG AAGG", + "CCCG CTT", + "ATGG CGCG", + "TATT TCG", + "TACG AGG", + "TGGG ATG", + "CGG ACC", + "TCGG CACG", + "TGAT TGG", + "ACGG TTG", + "TAA ACTT", + "CT ACAGG", + "TATGG GG", + "CC TTTTTT", + "A C", + "ACAG ATG", + "CACA TGG", + "AACG AGG", + "CT ATCCG", + "CCA TTCG", + "CCGGCG TCG", + "AT CGGGCG", + "TCA CTT", + "TCT ACTT", + "ATCTG AG", + "CGG TGGCG", + "ATTG TAG", + "TCCG TTG", + "CTG CTGCG", + "CAAG CGCG", + "CAGCG ACG", + "AATT TAT", + "TG AAAA", + "AT CTGGCG", + "CCTT TAA", + "AGGG TCG", + "AATG TTG", + "AGGG CGCG", + "TG CCTG", + "AAAT CAG", + "CCGCCG CCGCCG", + "TT AAG", + "CCTCG AAG", + "CGGTG ATG", + "TTTTG CA", + "TCC TGTG", + "TCCG CCGG", + "ACT CTTG", + "ACC TCGAG", + "TG TAT", + "TAG CGCG", + "CTTCA TCA", + "CAAA TTTT", + "TCC CCAG", + "AAAG ATG", + "CCCA ATT", + "ACA ACAG", + "TGG AGCG", + "ATGG TAA", + "TACGG CA", + "CTGG CGCA", + "TCC CTTG", + "TATG AAG", + "CATG ATT", + "CAAG TCA", + "CCA AGAA", + "TACA AAG", + "CACG AGCG", + "CCG CCCGG", + "CTTTT TCA", + "CAG ACGG", + "TCC CGGCG", + "ACG TTCG", + "ACG CGAG", + "CTTCA TCG", + "TTCA TAA", + "TCAGG CA", + "ACG CAGG", + "CTGG TCGG", + "ACT CCCG", + "AAAT AAG", + "ACCAG TT", + "TAT TGAG", + "CCG CTCA", + "CAG TTTT", + "CTGG CGGG", + "ATGG CGAG", + "ACG AGCA", + "ATAG TAA", + "CCTG CGGG", + "CCGCG AGCG", + "ATTG TTTT", + "TAT ATAT", + "AATG ATT", + "CTCCA CA", + "TCGCG TCG", + "CT ATGCG", + "TTTCA TT", + "TACCA AG", + "CCGAG CTCG", + "CCA CGGG", + "ACC CCAG", + "AAGG CGAG", + "TAT TGCG", + "TTTG CGG", + "TCAG CTG", + "CGGCA TGG", + "ACA ACGG", + "AAGG CTG", + "ACCG CTT", + "CGGTG CTG", + "CAGCG TT", + "CCA ATCG", + "CCGCCG AGG", + "ACT CTGG", + "TCT AATT", + "CCGG TCGG", + "CCCGG TT", + "CCGCG TGG", + "TGGCG CCG", + "ATCA TTTT", + "CTCG CTCG", + "AAGG TAA", + "TGTT TCA", + "TGAA TGG", + "TATG ATT", + "TTCG CTG", + "CCA ACAG", + "TGAA TTG", + "ACTT TCG", + "CTTCG AGG", + "CCCA CAG", + "TCTT CGAG", + "CAGG TAA", + "TCTGGG CG", + "TACT TGG", + "CTTGG TG", + "ACT AATT", + "CCGGGG GG", + "TCGG TTG", + "CGGTG AAG", + "CACA TTG", + "ACC CTCA", + "TCC TCGCG", + "TCC TCGAG", + "AGAG CAG", + "AGCG CTT", + "CAGCA TCG", + "CGGTG TCG", + "CCTCGG CA", + "TCT TGAT", + "CGCGCG AA", + "CGG TCGCG", + "CCCCA CA", + "TGCAG AA", + "TCAG TGG", + "TCGG AAG", + "TAT ATTTT", + "ACGG CCGG", + "AGG ATGG", + "TACC TCG", + "CT CTGAA", + "TCTG ATG", + "CAAA CTG", + "AACA TGG", + "TTTT CTG", + "TCCA ACG", + "TGTTG AG", + "TCAG CTT", + "TGGGG AA", + "TGAG CAG", + "TGGG CTG", + "CGGCGG AA", + "TG ATCA", + "CCG TTGG", + "TCT ACC", + "AGGG CCA", + "TCAG ATT", + "AT CAGGCG", + "CAAA ACT", + "AGGG AAG", + "CCG AGGCG", + "CGGG ATT", + "CGGG CTT", + "TG ACCA", + "CATT CCA", + "TACAG CA", + "CGG TAT", + "CCG CATG", + "AAAG TTG", + "ATAG AGG", + "TG CATG", + "CCGAG CAGG", + "TCT CTGG", + "TCC CAAG", + "ACCG CCGG", + "ATCG CTT", + "ATCCA TT", + "CAG ATCA", + "TGAA ACA", + "CACA CCA", + "ATAT AAAA", + "CTTG CGCG", + "TCAG ATG", + "TGGG ATT", + "TTTT AAAA", + "TAT AAAT", + "CT ACGGCG", + "CACG CCCG", + "CGGG CGCA", + "CCA TTGG", + "TGCG ATG", + "TTCA AAAA", + "CCA TTTG", + "ACGCG CTG", + "ACT ACGG", + "ACAG ATT", + "ACT CCTT", + "TAT CCGG", + "CAAA CTT", + "ACC TCGGCG", + "TACA AGG", + "AGAG CGG", + "TGAA TCA", + "ACCGG TG", + "TGG AAAA", + "TCC CATT", + "AACG TCA", + "ATG TTGG", + "AT CCAGCG", + "TTAA AAG", + "CCGCCG CGG", + "CCTGG TT", + "TGGCG TCG", + "TGACG AA", + "AAGG CTT", + "CCCG ATT", + "CTCAG AG", + "ACC CACA", + "TCTT TAT", + "ATAAAA TT", + "TGG CGGCG", + "ACA ATAA", + "AT ACCTT", + "ACAGG CA", + "CATG TCA", + "CC TAAAG", + "ATG ACCA", + "ATG TTCG", + "TCAG CGAG", + "ATCT ACG", + "CCCGG CGCG", + "TGCG CTCG", + "TTTG AAAA", + "TGG TGGG", + "CCCG CAGG", + "CCCG ATCG", + "ACC CATT", + "TATG TTG", + "CACG TAG", + "ATG ATCA", + "CAG ATTG", + "CCAG ACA", + "AGCG CGGCG", + "ACGG CGGG", + "TCAGGG CG", + "CAG CAGCA", + "ACAG CGCG", + "CCTG TTCG", + "AT AAGCG", + "TCCGG TG", + "CTTTT TTG", + "TATCG AA", + "CCGCG TTG", + "CTGG CTGG", + "TCTCG CA", + "ACA AACA", + "ACGG CCAG", + "CCA ACCA", + "CCTGG CGG", + "CTGCG CGG", + "TTTG TTTT", + "AAG ATCA", + "CCGG CATCG", + "ACT TGTG", + "CCGGG CTG", + "CT ATCCA", + "ATCTT TG", + "TCC CACA", + "AAG CAGG", + "AATT TCG", + "CTCGG CCA", + "TGGCG CTG", + "TATG ATG", + "CCG TCAG", + "TCTG ATT", + "AGCG TTG", + "AT ATGAG", + "AATT CTT", + "CAAG CTCG", + "ACG CCAG", + "TGCAG AG", + "CCGGCG AGG", + "CAAA CGG", + "TGAG CGCG", + "CATG CGCG", + "ACA TCCA", + "ACG AAAA", + "TTCA CGG", + "ACGG ATG", + "ACCG ATT", + "TGG ATGG", + "ACGCG CTCG", + "T C", + "TGAA ATG", + "ACGGGG CG", + "TGAG CGG", + "TAT AATG", + "TGCT CCA", + "ACC TATT", + "ACTT ATT", + "ACA TCAG", + "CCGAG ATCG", + "ATAA TCG", + "CCT ACTG", + "CTCGG CGCG", + "TGG CTCG", + "TCT CCCA", + "AAAG AAAA", + "CCTG TCA", + "TCT CCTCG", + "TGG CAGG", + "CCAGG TT", + "ATCAG TT", + "AGCG ATT", + "AT CTCGAG", + "ACAG CTG", + "CACG ATT", + "TG TGCG", + "CCGGG CGCG", + "CCCC CCA", + "CAG ACT", + "ACA TCCG", + "AAGG CGCG", + "TAT CCAG", + "CCTTG CCG", + "ATATT TTTT", + "TAA ATCA", + "CTT CCCA", + "TG TTTT", + "TTG TTGG", + "CAAA CCG", + "CCCG CGGG", + "TTTG ACG", + "TAT TGAT", + "CAAA AGAA", + "AAAG AGG", + "TCGG CATCG", + "CTGG AGCG", + "TCGAG CAGG", + "AGGGG AA", + "CT ATTTG", + "TAAAA AAG", + "CAG TGCG", + "TATGG AA", + "TAA AGTT", + "ACAG CTT", + "CCA ATGG", + "TCGG ACA", + "TG TTGG", + "CATG ACA", + "CC TCAGCG", + "ATG AATG", + "TATT TCTT", + "TAAG ATT", + "CTTCG TT", + "CTG CGGCG", + "AGGG TCA", + "CCAG CTTG", + "ACT ACCA", + "TGCA TGG", + "AAG CCCG", + "TAT TGTG", + "CCA CTCG", + "ACAG TGG", + "CACG CTGG", + "CTT CTCA", + "CACA CCG", + "ACTG ATT", + "TATT AAAA", + "ATTGG TT", + "AGAA AGAA", + "ACGCG TT", + "CAG TTGG", + "TGATG CA", + "AAGCG TT", + "CCGCG ACCG", + "AACA ACG", + "CCGCCG TG", + "TACA TGG", + "TAT TGGG", + "CCA AAGG", + "TCT ACGG", + "TTTG ACA", + "CTG AATG", + "CGG CTCA", + "CCA CTGG", + "CCGGGG AG", + "CACA ACG", + "TAA ATTG", + "AT AGGAA", + "TATGG AG", + "TAG ATAA", + "CT ATGGG", + "ACC TCGCCG", + "CGG CCCGG", + "AGCG CCTG", + "CCTT CTTG", + "CCCC CGCG", + "TCG ACCA", + "TTG CGCA", + "CTCGCG AG", + "CT CCTGCG", + "CGG CGGTG", + "CGG TTGG", + "CTG TTCA", + "TCCA ATG", + "CGG ACT", + "CAGCA TCA", + "AGG ACT", + "CCTCG TT", + "CCGG ACGG", + "AGG TTTT", + "CCG TCGCG", + "ATCG TCGG", + "AGG AGAA", + "TACG CCA", + "TCC CCTG", + "TCT CTCG", + "ATG ATAA", + "CAGG TCGG", + "ACC TATG", + "CCGG AGCG", + "AT ACGAA", + "AAG CGGG", + "TGCCG TCG", + "ACA AAGG", + "CTCGGCG AG", + "AT AAGGG", + "CCAG TTCG", + "TAT ACTT", + "TCCAG TT", + "CTT TATG", + "CCG TCCA", + "AGG CTGG", + "CCG ACAG", + "ACA TGAA", + "ACC TCGACG", + "TACA TTG", + "AT CCCGAG", + "CGG CCTT", + "CATCG CA", + "CT CTGAG", + "TG TTTG", + "TAAAA TAA", + "T AAGGCG", + "TACCG AG", + "TAT CAGG", + "TAT AGAA", + "AAG ACGG", + "CCCT CTT", + "AAAA CAAA", + "CAG TTTG", + "CCA TGGG", + "CTGCG TT", + "AAG ACCG", + "TGG ACGG", + "TAG ATGG", + "ACT CATT", + "CCG AGAA", + "CTTG TAA", + "ACC TTCT", + "TGAA TAA", + "ACG TGCG", + "CCG TGGG", + "TCC TGGCG", + "ATCA CTT", + "CAAG ATCG", + "ATAT ACA", + "TGTT TGG", + "TCTT TCT", + "TCC TCGGG", + "ACT ATTG", + "TTCA TCT", + "AT ACCTG", + "TTG CAGG", + "ATAA CTT", + "TCGCG TG", + "CGAG CAG", + "ATT CCGG", + "AGG TGCG", + "TCAG CTCG", + "ATAA AGAA", + "CGAG CGG", + "CGGCGG CGGCGG", + "TTGG ACA", + "TAT CTCG", + "AGGCG CTCG", + "TCCG CTT", + "TTG ACCG", + "CCTTG TT", + "TGCTG TT", + "TAT CTAA", + "TTG CCCG", + "TCG CCGCG", + "CCAGG CGG", + "CCTG ACCG", + "ACGCG CCG", + "CGGG TGCG", + "AAG AACA", + "AAAA TTAA", + "ATAT CAG", + "CCGG CATG", + "ACT ACCG", + "ATCTG TT", + "TCGG CCCG", + "TTGG ACG", + "CT ATGAA", + "TCC TGCCG", + "TCTG CGCG", + "CCGGCG CGG", + "TCGAG CGG", + "CCTGG TGG", + "TTTT ACA", + "CTCAG AA", + "CGGG ACA", + "CGGG CCAG", + "CCCT CAG", + "TCTT CCG", + "ACTGGG CG", + "CGGGG TCG", + "TGCA AGG", + "ATCG ACGG", + "AAAT CAAA", + "AAAA TGAA", + "TCA TCAG", + "AATT CCA", + "CCCT CGGCG", + "CCGGG CAG", + "TAA CAAA", + "AGGGG CA", + "CAGGGG CG", + "AT AAGAG", + "ATG ATTG", + "TTTG TAG", + "TACG CGG", + "TG ATTG", + "AAG ACC", + "TTTG CTT", + "TCGTCG TCG", + "CCAG CAGCG", + "CCTT CACG", + "CAGG ATCG", + "TGAT CAG", + "ATG AACA", + "CCCAG TT", + "ACGG ACA", + "ATGCG TT", + "TGGG ACA", + "TG TCT", + "AAAT CGG", + "ATAG CCG", + "CCCG CACG", + "ACT AAAG", + "TCTT TAG", + "ATCT CAG", + "TCGG ATT", + "TCC TCGGCG", + "CC CCGGGG", + "TGG AAGG", + "TTGG CTT", + "CGCG ATT", + "ACCGG TT", + "TAT CGCA", + "CGCG CTT", + "ATG CAAA", + "TAT AAATT", + "TACTG CA", + "TCCG CCAG", + "ACC TCGGG", + "TTTT TGAA", + "CTGCG CCA", + "ACAG AGG", + "CTCT ATT", + "AAGAA AAG", + "AGCG CCGG", + "CGGG TAG", + "TGCG TCA", + "TACG ACA", + "CTGG ATCG", + "TCG CCAG", + "ACCA TCT", + "ACGG ATT", + "TCGAG CCG", + "ACC CCCA", + "TGAT CCA", + "TGGCG AAG", + "AGGG TTG", + "AT ACGAG", + "CGGCG TCGG", + "TACC TTG", + "CGGG CAAG", + "CCCTTG CG", + "TAA TCC", + "ACT CTCG", + "CAGCG AGG", + "TG TCC", + "AGCA TCT", + "AGAG ATT", + "CAG AATG", + "ACTG TCA", + "AACG AAG", + "ATCG TCT", + "TGCA CCA", + "CTTG CTT", + "CCGAG AAG", + "AAAA ACTT", + "CGAG CCG", + "TACG TCA", + "AGTT TGG", + "AACG ACA", + "TAGG TGG", + "TGCA ACA", + "ACGGCG AA", + "CCGAG ACG", + "CCCGCG CA", + "CGG ATTG", + "CCCG CCTG", + "CAAG TAA", + "TAT CCTG", + "ACAG TCA", + "AGGG CTG", + "AAAA ATTG", + "TCTT ATT", + "CCCA TCT", + "AAAG TAA", + "CCGCG CAGG", + "TCGCCG TCG", + "CGCG CCAG", + "AACA CCG", + "TCGG ATG", + "TATT ACA", + "TATT TTAA", + "CTGG TAA", + "AAAA CTG", + "AGG AATT", + "TGCG TTG", + "TTCA TTTT", + "CTGG CTT", + "CCCG TAG", + "CGG ATCA", + "TACCG CA", + "CCCG ACCG", + "ACTG TCG", + "ACC CCTG", + "CAAG CTT", + "CCCA CTG", + "CCTTTG CG", + "CAG TCT", + "CACG ACCG", + "TCCG CTCG", + "CGGCG ATGG", + "TGCA ATT", + "CT AAAAAA", + "TGCA AAG", + "TTCG CCGG", + "TGAAG CA", + "CTCA TCT", + "CTAA TTG", + "AATG CCG", + "TGCTG CTG", + "ACTG ACG", + "TCTG CTT", + "CAG ACCA", + "ATCT CTG", + "ATAT ATG", + "TGCCG TT", + "CCACG TG", + "TCGCG ATG", + "TCGAG CTCG", + "CTCCA TT", + "TAG AGAA", + "CCTT CCAG", + "CAAG CGCA", + "TACA CCA", + "CCCGGG GG", + "TTTT ATG", + "ACA ATGG", + "CTCT CTT", + "TGCG AAG", + "TCGGCG TCG", + "TCGAG CTG", + "CGG CCAGG", + "AACA TTG", + "CGGCG CAGG", + "CCGGG ACG", + "CAG CCGCG", + "TGATG TT", + "CCG ACGCG", + "CCGG TCT", + "TCAG TCA", + "AACG TGG", + "CCTTTT CG", + "ACGG CCTG", + "CCTT CCTG", + "AGGG ATT", + "ACGAG CGCG", + "CCCCG ACG", + "TACC TCA", + "AGGCG ATG", + "TAG TTGG", + "CTCT CTG", + "CGG CTGCG", + "CGGGCG AA", + "TCAG CAGG", + "TAAG AAG", + "TCG TTCG", + "TAG AAGG", + "TCG ACT", + "AGGG CTT", + "ACGG CTCG", + "CCCG CGGCG", + "AAAT CTG", + "TCTT CGCG", + "TCTG TGG", + "CC TATAA", + "TCTG CTCG", + "TAG TATT", + "CAG CATT", + "ATATT TTG", + "ACTT CTG", + "CCAG CATG", + "CAGG CTT", + "ACTT CGAG", + "AT ACACG", + "TCCA TAA", + "CCGG TGCCG", + "TACAG AA", + "ATAT CTG", + "CGGCGG CCG", + "TACG AAG", + "TCAG CACG", + "CAAGG CA", + "AGG AACG", + "CAGG CGCA", + "CT ACGAA", + "TCGGCG ACG", + "CCCTG TT", + "ACTCG CA", + "AGCA CGCG", + "ATAT CGG", + "CT ATCC", + "TCCA TCT", + "TG TCCG", + "CCA TCGCG", + "CCCA CGCG", + "CACA ATT", + "ACC TCGTCG", + "ATAT AAG", + "CCGCG ACA", + "CC TAATT", + "TCTG TCA", + "TCC TTCT", + "ACT ATAA", + "CAG TCGG", + "ACAG ACA", + "AGG TAT", + "CCTT CGGG", + "TCTT TCTT", + "ATCA TCGG", + "AT CCTGCG", + "ATCA CCGG", + "CGGCG ACCG", + "AATG TCA", + "CCGGG TGG", + "CGGTG CGG", + "CAAAG CA", + "CGCGCG CCG", + "CCACG TT", + "TCT CATT", + "CTCG CCGCG", + "TG CAAG", + "TAG ATCG", + "CAAA TATT", + "ACG AGAA", + "AAAG TCA", + "CCCATG CG", + "CCAG TAA", + "AGGG CAAG", + "TAG CGCA", + "AAAG CCA", + "TG ACT", + "CAGCG TCA", + "CT ACGACG", + "AGG TCC", + "CCGAG CACG", + "AATT TATT", + "ACG CTCA", + "AAAG CCG", + "CGGG AGCG", + "ACA ACCA", + "CAGCG TGG", + "CCGG CCTCG", + "CTGG CGAG", + "CCGG TAA", + "CGGG TCGG", + "ACG CCGCG", + "AT ACTTG", + "CTCG ATGG", + "CTGG CCCG", + "CCTG CTTG", + "ATAG TCA", + "CCCT CTG", + "TAAG TAA", + "CTGG TGCG", + "TGAT CTT", + "TGCA TTG", + "TAG TCGG", + "CCGACG AA", + "TGAA AGG", + "CT ACATT", + "TCG AGAA", + "ACTG TGG", + "TTCG CAG", + "ACTT CCG", + "CATT CTT", + "CAAA ATAA", + "TCCG ATT", + "ACGAG CTG" + ] + } +} \ No newline at end of file diff --git a/tokenizer_config.json b/tokenizer_config.json new file mode 100644 index 0000000..366e2a5 --- /dev/null +++ b/tokenizer_config.json @@ -0,0 +1,52 @@ +{ + "added_tokens_decoder": { + "0": { + "content": "[UNK]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "1": { + "content": "[CLS]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "2": { + "content": "[SEP]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "3": { + "content": "[PAD]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + }, + "4": { + "content": "[MASK]", + "lstrip": false, + "normalized": false, + "rstrip": false, + "single_word": false, + "special": true + } + }, + "clean_up_tokenization_spaces": true, + "cls_token": "[CLS]", + "mask_token": "[MASK]", + "model_max_length": 1000000000000000019884624838656, + "pad_token": "[PAD]", + "sep_token": "[SEP]", + "tokenizer_class": "PreTrainedTokenizerFast", + "unk_token": "[UNK]" +}