lgq12697 commited on
Commit
d8cd482
1 Parent(s): 78d7dbc

Add Plant NT model for H3K27ac prediction

Browse files
Files changed (8) hide show
  1. README.md +63 -3
  2. config.json +45 -0
  3. esm_config.py +379 -0
  4. model.safetensors +3 -0
  5. modeling_esm.py +1446 -0
  6. special_tokens_map.json +6 -0
  7. tokenizer_config.json +44 -0
  8. vocab.txt +8003 -0
README.md CHANGED
@@ -1,3 +1,63 @@
1
- ---
2
- license: cc-by-nc-sa-4.0
3
- ---
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ ---
2
+ license: cc-by-nc-sa-4.0
3
+ widget:
4
+ - text: AGTCGCCGCAACCCACACACGGACGGCTCGACGTGGCGATCTTAGCGGCTCATCCGCCCGGCCTCCCTCGCGCTCGATCGCTACGCAGCCTACGCTCGTTTCGCTCGGTTCGGTGGGTCGCCGATCTGGCGCCACGGCGGCTACCAACGACACCGCGATTGAGAAGGGTGCGTGGCCGTGGAGTCGTGGAGAAACGCCCGCGCGCGCGGGTGCGGCGAGGGACGACGACCGCGTCGTGCGGATCGATTGGCGGGGCAGCTCGGCGCCCCG
5
+ tags:
6
+ - DNA
7
+ - biology
8
+ - genomics
9
+ ---
10
+ # Plant foundation DNA large language models
11
+
12
+ The plant DNA large language models (LLMs) contain a series of foundation models based on different model architectures, which are pre-trained on various plant reference genomes.
13
+ All the models have a comparable model size between 90 MB and 150 MB, BPE tokenizer is used for tokenization and 8000 tokens are included in the vocabulary.
14
+
15
+
16
+ **Developed by:** zhangtaolab
17
+
18
+ ### Model Sources
19
+
20
+ - **Repository:** [Plant DNA LLMs](https://github.com/zhangtaolab/plant_DNA_LLMs)
21
+ - **Manuscript:** [Versatile applications of foundation DNA language models in plant genomes]()
22
+
23
+ ### Architecture
24
+
25
+ The model is trained based on the InstaDeepAI/nucleotide-transformer-v2-100m-multi-species model with modified tokenizer that replaces k-mer to BPE.
26
+
27
+ This model is fine-tuned for predicting H3K27ac histone modification.
28
+
29
+
30
+ ### How to use
31
+
32
+ Install the runtime library first:
33
+ ```bash
34
+ pip install transformers
35
+ ```
36
+
37
+ Here is a simple code for inference:
38
+ ```python
39
+ from transformers import AutoModelForSequenceClassification, AutoTokenizer, pipeline
40
+
41
+ model_name = 'plant-nucleotide-transformer-H3K27ac'
42
+ # load model and tokenizer
43
+ model = AutoModelForSequenceClassification.from_pretrained(f'zhangtaolab/{model_name}', trust_remote_code=True)
44
+ tokenizer = AutoTokenizer.from_pretrained(f'zhangtaolab/{model_name}', trust_remote_code=True)
45
+
46
+ # inference
47
+ sequences = ['GCTTTGGTTTATACCTTACACAACATAAATCACATAGTTAATCCCTAATCGTCTTTGATTCTCAATGTTTTGTTCATTTTTACCATGAACATCATCTGATTGATAAGTGCATAGAGAATTAACGGCTTACACTTTACACTTGCATAGATGATTCCTAAGTATGTCCT',
48
+ 'TAGCCCCCTCCTCTCTTTATATAGTGCAATCTAATATATGAAAGGTTCGGTGATGGGGCCAATAAGTGTATTTAGGCTAGGCCTTCATGGGCCAAGCCCAAAAGTTTCTCAACACTCCCCCTTGAGCACTCACCGCGTAATGTCCATGCCTCGTCAAAACTCCATAAAAACCCAGTG']
49
+ pipe = pipeline('text-classification', model=model, tokenizer=tokenizer,
50
+ trust_remote_code=True, top_k=None)
51
+ results = pipe(sequences)
52
+ print(results)
53
+
54
+ ```
55
+
56
+
57
+ ### Training data
58
+ We use EsmForSequenceClassification to fine-tune the model.
59
+ Detailed training procedure can be found in our manuscript.
60
+
61
+
62
+ #### Hardware
63
+ Model was trained on a NVIDIA GTX1080Ti GPU (11 GB).
config.json ADDED
@@ -0,0 +1,45 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "_name_or_path": "Plant_NT_H3K27ac",
3
+ "add_bias_fnn": false,
4
+ "architectures": [
5
+ "EsmForSequenceClassification"
6
+ ],
7
+ "attention_probs_dropout_prob": 0.0,
8
+ "auto_map": {
9
+ "AutoConfig": "esm_config.EsmConfig",
10
+ "AutoModelForMaskedLM": "modeling_esm.EsmForMaskedLM",
11
+ "AutoModelForSequenceClassification": "modeling_esm.EsmForSequenceClassification",
12
+ "AutoModelForTokenClassification": "modeling_esm.EsmForTokenClassification"
13
+ },
14
+ "emb_layer_norm_before": false,
15
+ "esmfold_config": null,
16
+ "hidden_dropout_prob": 0.0,
17
+ "hidden_size": 512,
18
+ "id2label": {
19
+ "0": "Not H3K27ac",
20
+ "1": "H3K27ac"
21
+ },
22
+ "initializer_range": 0.02,
23
+ "intermediate_size": 2048,
24
+ "is_folding_model": false,
25
+ "label2id": {
26
+ "Not H3K27ac": 0,
27
+ "H3K27ac": 1
28
+ },
29
+ "layer_norm_eps": 1e-12,
30
+ "mask_token_id": 2,
31
+ "max_position_embeddings": 2050,
32
+ "model_type": "esm",
33
+ "num_attention_heads": 16,
34
+ "num_hidden_layers": 22,
35
+ "pad_token_id": 1,
36
+ "position_embedding_type": "rotary",
37
+ "problem_type": "single_label_classification",
38
+ "tie_word_embeddings": false,
39
+ "token_dropout": false,
40
+ "torch_dtype": "float32",
41
+ "transformers_version": "4.39.1",
42
+ "use_cache": false,
43
+ "vocab_list": null,
44
+ "vocab_size": 8003
45
+ }
esm_config.py ADDED
@@ -0,0 +1,379 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # coding=utf-8
2
+ # Copyright 2022 Meta and The HuggingFace Inc. team. All rights reserved.
3
+ #
4
+ # Licensed under the Apache License, Version 2.0 (the "License");
5
+ # you may not use this file except in compliance with the License.
6
+ # You may obtain a copy of the License at
7
+ #
8
+ # http://www.apache.org/licenses/LICENSE-2.0
9
+ #
10
+ # Unless required by applicable law or agreed to in writing, software
11
+ # distributed under the License is distributed on an "AS IS" BASIS,
12
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
+ # See the License for the specific language governing permissions and
14
+ # limitations under the License.
15
+ """ ESM model configuration"""
16
+
17
+ from dataclasses import asdict, dataclass
18
+ from typing import Optional
19
+
20
+ from transformers import PretrainedConfig, logging
21
+
22
+ logger = logging.get_logger(__name__)
23
+
24
+ # TODO Update this
25
+ ESM_PRETRAINED_CONFIG_ARCHIVE_MAP = {
26
+ "facebook/esm-1b": "https://huggingface.co/facebook/esm-1b/resolve/main/config.json",
27
+ # See all ESM models at https://huggingface.co/models?filter=esm
28
+ }
29
+
30
+
31
+ class EsmConfig(PretrainedConfig):
32
+ r"""
33
+ This is the configuration class to store the configuration of a [`ESMModel`]. It is used to instantiate a ESM model
34
+ according to the specified arguments, defining the model architecture. Instantiating a configuration with the
35
+ defaults will yield a similar configuration to that of the ESM
36
+ [facebook/esm-1b](https://huggingface.co/facebook/esm-1b) architecture.
37
+
38
+ Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the
39
+ documentation from [`PretrainedConfig`] for more information.
40
+
41
+
42
+ Args:
43
+ vocab_size (`int`, *optional*):
44
+ Vocabulary size of the ESM model. Defines the number of different tokens that can be represented by the
45
+ `inputs_ids` passed when calling [`ESMModel`].
46
+ mask_token_id (`int`, *optional*):
47
+ The index of the mask token in the vocabulary. This must be included in the config because of the
48
+ "mask-dropout" scaling trick, which will scale the inputs depending on the number of masked tokens.
49
+ pad_token_id (`int`, *optional*):
50
+ The index of the padding token in the vocabulary. This must be included in the config because certain parts
51
+ of the ESM code use this instead of the attention mask.
52
+ hidden_size (`int`, *optional*, defaults to 768):
53
+ Dimensionality of the encoder layers and the pooler layer.
54
+ num_hidden_layers (`int`, *optional*, defaults to 12):
55
+ Number of hidden layers in the Transformer encoder.
56
+ num_attention_heads (`int`, *optional*, defaults to 12):
57
+ Number of attention heads for each attention layer in the Transformer encoder.
58
+ intermediate_size (`int`, *optional*, defaults to 3072):
59
+ Dimensionality of the "intermediate" (often named feed-forward) layer in the Transformer encoder.
60
+ hidden_dropout_prob (`float`, *optional*, defaults to 0.1):
61
+ The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.
62
+ attention_probs_dropout_prob (`float`, *optional*, defaults to 0.1):
63
+ The dropout ratio for the attention probabilities.
64
+ max_position_embeddings (`int`, *optional*, defaults to 1026):
65
+ The maximum sequence length that this model might ever be used with. Typically set this to something large
66
+ just in case (e.g., 512 or 1024 or 2048).
67
+ initializer_range (`float`, *optional*, defaults to 0.02):
68
+ The standard deviation of the truncated_normal_initializer for initializing all weight matrices.
69
+ layer_norm_eps (`float`, *optional*, defaults to 1e-12):
70
+ The epsilon used by the layer normalization layers.
71
+ position_embedding_type (`str`, *optional*, defaults to `"absolute"`):
72
+ Type of position embedding. Choose one of `"absolute"`, `"relative_key"`, `"relative_key_query", "rotary"`.
73
+ For positional embeddings use `"absolute"`. For more information on `"relative_key"`, please refer to
74
+ [Self-Attention with Relative Position Representations (Shaw et al.)](https://arxiv.org/abs/1803.02155).
75
+ For more information on `"relative_key_query"`, please refer to *Method 4* in [Improve Transformer Models
76
+ with Better Relative Position Embeddings (Huang et al.)](https://arxiv.org/abs/2009.13658).
77
+ is_decoder (`bool`, *optional*, defaults to `False`):
78
+ Whether the model is used as a decoder or not. If `False`, the model is used as an encoder.
79
+ use_cache (`bool`, *optional*, defaults to `True`):
80
+ Whether or not the model should return the last key/values attentions (not used by all models). Only
81
+ relevant if `config.is_decoder=True`.
82
+ emb_layer_norm_before (`bool`, *optional*):
83
+ Whether to apply layer normalization after embeddings but before the main stem of the network.
84
+ token_dropout (`bool`, defaults to `False`):
85
+ When this is enabled, masked tokens are treated as if they had been dropped out by input dropout.
86
+
87
+ Examples:
88
+
89
+ ```python
90
+ >>> from transformers import EsmModel, EsmConfig
91
+
92
+ >>> # Initializing a ESM facebook/esm-1b style configuration >>> configuration = EsmConfig()
93
+
94
+ >>> # Initializing a model from the configuration >>> model = ESMModel(configuration)
95
+
96
+ >>> # Accessing the model configuration >>> configuration = model.config
97
+ ```"""
98
+ model_type = "esm"
99
+
100
+ def __init__(
101
+ self,
102
+ vocab_size=None,
103
+ mask_token_id=None,
104
+ pad_token_id=None,
105
+ hidden_size=768,
106
+ num_hidden_layers=12,
107
+ num_attention_heads=12,
108
+ intermediate_size=3072,
109
+ hidden_dropout_prob=0.1,
110
+ attention_probs_dropout_prob=0.1,
111
+ max_position_embeddings=1026,
112
+ initializer_range=0.02,
113
+ layer_norm_eps=1e-12,
114
+ position_embedding_type="absolute",
115
+ use_cache=True,
116
+ emb_layer_norm_before=None,
117
+ token_dropout=False,
118
+ is_folding_model=False,
119
+ esmfold_config=None,
120
+ vocab_list=None,
121
+ add_bias_fnn=True,
122
+ **kwargs,
123
+ ):
124
+ super().__init__(
125
+ pad_token_id=pad_token_id, mask_token_id=mask_token_id, **kwargs
126
+ )
127
+
128
+ self.vocab_size = vocab_size
129
+ self.hidden_size = hidden_size
130
+ self.num_hidden_layers = num_hidden_layers
131
+ self.num_attention_heads = num_attention_heads
132
+ self.intermediate_size = intermediate_size
133
+ self.hidden_dropout_prob = hidden_dropout_prob
134
+ self.attention_probs_dropout_prob = attention_probs_dropout_prob
135
+ self.max_position_embeddings = max_position_embeddings
136
+ self.initializer_range = initializer_range
137
+ self.layer_norm_eps = layer_norm_eps
138
+ self.position_embedding_type = position_embedding_type
139
+ self.use_cache = use_cache
140
+ self.emb_layer_norm_before = emb_layer_norm_before
141
+ self.token_dropout = token_dropout
142
+ self.is_folding_model = is_folding_model
143
+ # Arguments needed for Dalmatian
144
+ self.add_bias_fnn = add_bias_fnn
145
+ if is_folding_model:
146
+ if esmfold_config is None:
147
+ logger.info(
148
+ "No esmfold_config supplied for folding model, using default values."
149
+ )
150
+ esmfold_config = EsmFoldConfig()
151
+ elif isinstance(esmfold_config, dict):
152
+ esmfold_config = EsmFoldConfig(**esmfold_config)
153
+ self.esmfold_config = esmfold_config
154
+ if vocab_list is None:
155
+ logger.warning(
156
+ "No vocab_list supplied for folding model, assuming the ESM-2 vocabulary!"
157
+ )
158
+ self.vocab_list = get_default_vocab_list()
159
+ else:
160
+ self.vocab_list = vocab_list
161
+ else:
162
+ self.esmfold_config = None
163
+ self.vocab_list = None
164
+ if self.esmfold_config is not None and getattr(
165
+ self.esmfold_config, "use_esm_attn_map", False
166
+ ):
167
+ raise ValueError(
168
+ "The HuggingFace port of ESMFold does not support use_esm_attn_map at this time!"
169
+ )
170
+
171
+ def to_dict(self):
172
+ """
173
+ Serializes this instance to a Python dictionary. Override the default [`~PretrainedConfig.to_dict`].
174
+
175
+ Returns:
176
+ `Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance,
177
+ """
178
+ output = super().to_dict()
179
+ if isinstance(self.esmfold_config, EsmFoldConfig):
180
+ output["esmfold_config"] = self.esmfold_config.to_dict()
181
+ return output
182
+
183
+
184
+ @dataclass
185
+ class EsmFoldConfig:
186
+ esm_type: str = None
187
+ fp16_esm: bool = True
188
+ use_esm_attn_map: bool = False
189
+ esm_ablate_pairwise: bool = False
190
+ esm_ablate_sequence: bool = False
191
+ esm_input_dropout: float = 0
192
+
193
+ embed_aa: bool = True
194
+ bypass_lm: bool = False
195
+
196
+ lddt_head_hid_dim: int = 128
197
+ trunk: "TrunkConfig" = None
198
+
199
+ def __post_init__(self):
200
+ if self.trunk is None:
201
+ self.trunk = TrunkConfig()
202
+ elif isinstance(self.trunk, dict):
203
+ self.trunk = TrunkConfig(**self.trunk)
204
+
205
+ def to_dict(self):
206
+ """
207
+ Serializes this instance to a Python dictionary. Override the default [`~PretrainedConfig.to_dict`].
208
+
209
+ Returns:
210
+ `Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance,
211
+ """
212
+ output = asdict(self)
213
+ output["trunk"] = self.trunk.to_dict()
214
+ return output
215
+
216
+
217
+ @dataclass
218
+ class TrunkConfig:
219
+ num_blocks: int = 48
220
+ sequence_state_dim: int = 1024
221
+ pairwise_state_dim: int = 128
222
+ sequence_head_width: int = 32
223
+ pairwise_head_width: int = 32
224
+ position_bins: int = 32
225
+ dropout: float = 0
226
+ layer_drop: float = 0
227
+ cpu_grad_checkpoint: bool = False
228
+ max_recycles: int = 4
229
+ chunk_size: Optional[int] = 128
230
+ structure_module: "StructureModuleConfig" = None
231
+
232
+ def __post_init__(self):
233
+ if self.structure_module is None:
234
+ self.structure_module = StructureModuleConfig()
235
+ elif isinstance(self.structure_module, dict):
236
+ self.structure_module = StructureModuleConfig(**self.structure_module)
237
+
238
+ if self.max_recycles <= 0:
239
+ raise ValueError(
240
+ f"`max_recycles` should be positive, got {self.max_recycles}."
241
+ )
242
+ if self.sequence_state_dim % self.sequence_state_dim != 0:
243
+ raise ValueError(
244
+ "`sequence_state_dim` should be a round multiple of `sequence_state_dim`, got"
245
+ f" {self.sequence_state_dim} and {self.sequence_state_dim}."
246
+ )
247
+ if self.pairwise_state_dim % self.pairwise_state_dim != 0:
248
+ raise ValueError(
249
+ "`pairwise_state_dim` should be a round multiple of `pairwise_state_dim`, got"
250
+ f" {self.pairwise_state_dim} and {self.pairwise_state_dim}."
251
+ )
252
+
253
+ sequence_num_heads = self.sequence_state_dim // self.sequence_head_width
254
+ pairwise_num_heads = self.pairwise_state_dim // self.pairwise_head_width
255
+
256
+ if self.sequence_state_dim != sequence_num_heads * self.sequence_head_width:
257
+ raise ValueError(
258
+ "`sequence_state_dim` should be equal to `sequence_num_heads * sequence_head_width, got"
259
+ f" {self.sequence_state_dim} != {sequence_num_heads} * {self.sequence_head_width}."
260
+ )
261
+ if self.pairwise_state_dim != pairwise_num_heads * self.pairwise_head_width:
262
+ raise ValueError(
263
+ "`pairwise_state_dim` should be equal to `pairwise_num_heads * pairwise_head_width, got"
264
+ f" {self.pairwise_state_dim} != {pairwise_num_heads} * {self.pairwise_head_width}."
265
+ )
266
+ if self.pairwise_state_dim % 2 != 0:
267
+ raise ValueError(
268
+ f"`pairwise_state_dim` should be even, got {self.pairwise_state_dim}."
269
+ )
270
+
271
+ if self.dropout >= 0.4:
272
+ raise ValueError(
273
+ f"`dropout` should not be greater than 0.4, got {self.dropout}."
274
+ )
275
+
276
+ def to_dict(self):
277
+ """
278
+ Serializes this instance to a Python dictionary. Override the default [`~PretrainedConfig.to_dict`].
279
+
280
+ Returns:
281
+ `Dict[str, any]`: Dictionary of all the attributes that make up this configuration instance,
282
+ """
283
+ output = asdict(self)
284
+ output["structure_module"] = self.structure_module.to_dict()
285
+ return output
286
+
287
+
288
+ @dataclass
289
+ class StructureModuleConfig:
290
+ """
291
+ Args:
292
+ sequence_dim:
293
+ Single representation channel dimension
294
+ pairwise_dim:
295
+ Pair representation channel dimension
296
+ ipa_dim:
297
+ IPA hidden channel dimension
298
+ resnet_dim:
299
+ Angle resnet (Alg. 23 lines 11-14) hidden channel dimension
300
+ num_heads_ipa:
301
+ Number of IPA heads
302
+ num_qk_points:
303
+ Number of query/key points to generate during IPA
304
+ num_v_points:
305
+ Number of value points to generate during IPA
306
+ dropout_rate:
307
+ Dropout rate used throughout the layer
308
+ num_blocks:
309
+ Number of structure module blocks
310
+ num_transition_layers:
311
+ Number of layers in the single representation transition (Alg. 23 lines 8-9)
312
+ num_resnet_blocks:
313
+ Number of blocks in the angle resnet
314
+ num_angles:
315
+ Number of angles to generate in the angle resnet
316
+ trans_scale_factor:
317
+ Scale of single representation transition hidden dimension
318
+ epsilon:
319
+ Small number used in angle resnet normalization
320
+ inf:
321
+ Large number used for attention masking
322
+ """
323
+
324
+ sequence_dim: int = 384
325
+ pairwise_dim: int = 128
326
+ ipa_dim: int = 16
327
+ resnet_dim: int = 128
328
+ num_heads_ipa: int = 12
329
+ num_qk_points: int = 4
330
+ num_v_points: int = 8
331
+ dropout_rate: float = 0.1
332
+ num_blocks: int = 8
333
+ num_transition_layers: int = 1
334
+ num_resnet_blocks: int = 2
335
+ num_angles: int = 7
336
+ trans_scale_factor: int = 10
337
+ epsilon: float = 1e-8
338
+ inf: float = 1e5
339
+
340
+ def to_dict(self):
341
+ return asdict(self)
342
+
343
+
344
+ def get_default_vocab_list():
345
+ return (
346
+ "<cls>",
347
+ "<pad>",
348
+ "<eos>",
349
+ "<unk>",
350
+ "L",
351
+ "A",
352
+ "G",
353
+ "V",
354
+ "S",
355
+ "E",
356
+ "R",
357
+ "T",
358
+ "I",
359
+ "D",
360
+ "P",
361
+ "K",
362
+ "Q",
363
+ "N",
364
+ "F",
365
+ "Y",
366
+ "M",
367
+ "H",
368
+ "W",
369
+ "C",
370
+ "X",
371
+ "B",
372
+ "U",
373
+ "Z",
374
+ "O",
375
+ ".",
376
+ "-",
377
+ "<null_1>",
378
+ "<mask>",
379
+ )
model.safetensors ADDED
@@ -0,0 +1,3 @@
 
 
 
 
1
+ version https://git-lfs.github.com/spec/v1
2
+ oid sha256:100163c725792213fb870569d51af69c7abe2868c810b44d463fb002739af7e5
3
+ size 391148900
modeling_esm.py ADDED
@@ -0,0 +1,1446 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ # coding=utf-8
2
+ # Copyright 2022 Meta and The HuggingFace Inc. team. All rights reserved.
3
+ #
4
+ # Licensed under the Apache License, Version 2.0 (the "License");
5
+ # you may not use this file except in compliance with the License.
6
+ # You may obtain a copy of the License at
7
+ #
8
+ # http://www.apache.org/licenses/LICENSE-2.0
9
+ #
10
+ # Unless required by applicable law or agreed to in writing, software
11
+ # distributed under the License is distributed on an "AS IS" BASIS,
12
+ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
+ # See the License for the specific language governing permissions and
14
+ # limitations under the License.
15
+ """ PyTorch ESM model."""
16
+
17
+ import math
18
+ from typing import List, Optional, Tuple, Union
19
+
20
+ import torch
21
+ import torch.utils.checkpoint
22
+ from torch import nn
23
+ from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss, SiLU
24
+ from transformers.file_utils import (
25
+ add_code_sample_docstrings,
26
+ add_start_docstrings,
27
+ add_start_docstrings_to_model_forward,
28
+ )
29
+ from transformers.modeling_outputs import (
30
+ BaseModelOutputWithPastAndCrossAttentions,
31
+ BaseModelOutputWithPoolingAndCrossAttentions,
32
+ MaskedLMOutput,
33
+ SequenceClassifierOutput,
34
+ TokenClassifierOutput,
35
+ )
36
+ from transformers.modeling_utils import (
37
+ PreTrainedModel,
38
+ find_pruneable_heads_and_indices,
39
+ prune_linear_layer,
40
+ )
41
+ from transformers.utils import logging
42
+
43
+ from .esm_config import EsmConfig
44
+
45
+ logger = logging.get_logger(__name__)
46
+
47
+ _CHECKPOINT_FOR_DOC = "facebook/esm2_t6_8M_UR50D"
48
+ _CONFIG_FOR_DOC = "EsmConfig"
49
+
50
+ ESM_PRETRAINED_MODEL_ARCHIVE_LIST = [
51
+ "facebook/esm2_t6_8M_UR50D",
52
+ "facebook/esm2_t12_35M_UR50D",
53
+ # This is not a complete list of all ESM models!
54
+ # See all ESM models at https://huggingface.co/models?filter=esm
55
+ ]
56
+
57
+
58
+ def rotate_half(x):
59
+ x1, x2 = x.chunk(2, dim=-1)
60
+ return torch.cat((-x2, x1), dim=-1)
61
+
62
+
63
+ def apply_rotary_pos_emb(x, cos, sin):
64
+ cos = cos[:, :, : x.shape[-2], :]
65
+ sin = sin[:, :, : x.shape[-2], :]
66
+
67
+ return (x * cos) + (rotate_half(x) * sin)
68
+
69
+
70
+ def gelu(x):
71
+ """
72
+ This is the gelu implementation from the original ESM repo. Using F.gelu yields subtly wrong results.
73
+ """
74
+ return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
75
+
76
+
77
+ def symmetrize(x):
78
+ "Make layer symmetric in final two dimensions, used for contact prediction."
79
+ return x + x.transpose(-1, -2)
80
+
81
+
82
+ def average_product_correct(x):
83
+ "Perform average product correct, used for contact prediction."
84
+ a1 = x.sum(-1, keepdims=True)
85
+ a2 = x.sum(-2, keepdims=True)
86
+ a12 = x.sum((-1, -2), keepdims=True)
87
+
88
+ avg = a1 * a2
89
+ avg.div_(a12) # in-place to reduce memory
90
+ normalized = x - avg
91
+ return normalized
92
+
93
+
94
+ class RotaryEmbedding(torch.nn.Module):
95
+ """
96
+ Rotary position embeddings based on those in
97
+ [RoFormer](https://huggingface.co/docs/transformers/model_doc/roformer). Query and keys are transformed by rotation
98
+ matrices which depend on their relative positions.
99
+ """
100
+
101
+ def __init__(self, dim: int):
102
+ super().__init__()
103
+ # Generate and save the inverse frequency buffer (non trainable)
104
+ inv_freq = 1.0 / (10000 ** (torch.arange(0, dim, 2).float() / dim))
105
+ inv_freq = inv_freq
106
+ self.register_buffer("inv_freq", inv_freq)
107
+
108
+ self._seq_len_cached = None
109
+ self._cos_cached = None
110
+ self._sin_cached = None
111
+
112
+ def _update_cos_sin_tables(self, x, seq_dimension=2):
113
+ seq_len = x.shape[seq_dimension]
114
+
115
+ # Reset the tables if the sequence length has changed,
116
+ # or if we're on a new device (possibly due to tracing for instance)
117
+ if seq_len != self._seq_len_cached or self._cos_cached.device != x.device:
118
+ self._seq_len_cached = seq_len
119
+ t = torch.arange(x.shape[seq_dimension], device=x.device).type_as(
120
+ self.inv_freq
121
+ )
122
+ freqs = torch.outer(t, self.inv_freq)
123
+ emb = torch.cat((freqs, freqs), dim=-1).to(x.device)
124
+
125
+ self._cos_cached = emb.cos()[None, None, :, :]
126
+ self._sin_cached = emb.sin()[None, None, :, :]
127
+
128
+ return self._cos_cached, self._sin_cached
129
+
130
+ def forward(
131
+ self, q: torch.Tensor, k: torch.Tensor
132
+ ) -> Tuple[torch.Tensor, torch.Tensor]:
133
+ self._cos_cached, self._sin_cached = self._update_cos_sin_tables(
134
+ k, seq_dimension=-2
135
+ )
136
+
137
+ return (
138
+ apply_rotary_pos_emb(q, self._cos_cached, self._sin_cached),
139
+ apply_rotary_pos_emb(k, self._cos_cached, self._sin_cached),
140
+ )
141
+
142
+
143
+ class EsmContactPredictionHead(nn.Module):
144
+ """Performs symmetrization, apc, and computes a logistic regression on the output features"""
145
+
146
+ def __init__(
147
+ self,
148
+ in_features: int,
149
+ bias=True,
150
+ eos_idx: int = 2,
151
+ ):
152
+ super().__init__()
153
+ self.in_features = in_features
154
+ self.eos_idx = eos_idx
155
+ self.regression = nn.Linear(in_features, 1, bias)
156
+ self.activation = nn.Sigmoid()
157
+
158
+ def forward(self, tokens, attentions):
159
+ # remove eos token attentions
160
+ eos_mask = tokens.ne(self.eos_idx).to(attentions)
161
+ eos_mask = eos_mask.unsqueeze(1) * eos_mask.unsqueeze(2)
162
+ attentions = attentions * eos_mask[:, None, None, :, :]
163
+ attentions = attentions[..., :-1, :-1]
164
+ # remove cls token attentions
165
+ attentions = attentions[..., 1:, 1:]
166
+ batch_size, layers, heads, seqlen, _ = attentions.size()
167
+ attentions = attentions.view(batch_size, layers * heads, seqlen, seqlen)
168
+
169
+ # features: batch x channels x tokens x tokens (symmetric)
170
+ attentions = attentions.to(
171
+ self.regression.weight.device
172
+ ) # attentions always float32, may need to convert to float16
173
+ attentions = average_product_correct(symmetrize(attentions))
174
+ attentions = attentions.permute(0, 2, 3, 1)
175
+ return self.activation(self.regression(attentions).squeeze(3))
176
+
177
+
178
+ class EsmEmbeddings(nn.Module):
179
+ """
180
+ Same as BertEmbeddings with a tiny tweak for positional embeddings indexing.
181
+ """
182
+
183
+ def __init__(self, config):
184
+ super().__init__()
185
+ self.word_embeddings = nn.Embedding(
186
+ config.vocab_size, config.hidden_size, padding_idx=config.pad_token_id
187
+ )
188
+
189
+ if config.emb_layer_norm_before:
190
+ self.layer_norm = nn.LayerNorm(
191
+ config.hidden_size, eps=config.layer_norm_eps
192
+ )
193
+ else:
194
+ self.layer_norm = None
195
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
196
+ # position_ids (1, len position emb) is contiguous in memory and exported when serialized
197
+ self.position_embedding_type = getattr(
198
+ config, "position_embedding_type", "absolute"
199
+ )
200
+ self.register_buffer(
201
+ "position_ids",
202
+ torch.arange(config.max_position_embeddings).expand((1, -1)),
203
+ persistent=False,
204
+ )
205
+
206
+ self.padding_idx = config.pad_token_id
207
+ self.position_embeddings = nn.Embedding(
208
+ config.max_position_embeddings,
209
+ config.hidden_size,
210
+ padding_idx=self.padding_idx,
211
+ )
212
+ self.token_dropout = config.token_dropout
213
+ self.mask_token_id = config.mask_token_id
214
+
215
+ def forward(
216
+ self,
217
+ input_ids=None,
218
+ attention_mask=None,
219
+ position_ids=None,
220
+ inputs_embeds=None,
221
+ past_key_values_length=0,
222
+ ):
223
+ if position_ids is None:
224
+ if input_ids is not None:
225
+ # Create the position ids from the input token ids. Any padded tokens remain padded.
226
+ position_ids = create_position_ids_from_input_ids(
227
+ input_ids, self.padding_idx, past_key_values_length
228
+ )
229
+ else:
230
+ position_ids = self.create_position_ids_from_inputs_embeds(
231
+ inputs_embeds
232
+ )
233
+
234
+ if inputs_embeds is None:
235
+ inputs_embeds = self.word_embeddings(input_ids)
236
+
237
+ # Note that if we want to support ESM-1 (not 1b!) in future then we need to support an
238
+ # embedding_scale factor here.
239
+ embeddings = inputs_embeds
240
+
241
+ # Matt: ESM has the option to handle masking in MLM in a slightly unusual way. If the token_dropout
242
+ # flag is False then it is handled in the same was as BERT/RoBERTa. If it is set to True, however,
243
+ # masked tokens are treated as if they were selected for input dropout and zeroed out.
244
+ # This "mask-dropout" is compensated for when masked tokens are not present, by scaling embeddings by
245
+ # a factor of (fraction of unmasked tokens during training) / (fraction of unmasked tokens in sample).
246
+ # This is analogous to the way that dropout layers scale down outputs during evaluation when not
247
+ # actually dropping out values (or, equivalently, scale up their un-dropped outputs in training).
248
+ if self.token_dropout:
249
+ embeddings.masked_fill_(
250
+ (input_ids == self.mask_token_id).unsqueeze(-1), 0.0
251
+ )
252
+ mask_ratio_train = (
253
+ 0.15 * 0.8
254
+ ) # Hardcoded as the ratio used in all ESM model training runs
255
+ src_lengths = attention_mask.sum(-1)
256
+ mask_ratio_observed = (input_ids == self.mask_token_id).sum(
257
+ -1
258
+ ).float() / src_lengths
259
+ embeddings = (
260
+ embeddings
261
+ * (1 - mask_ratio_train)
262
+ / (1 - mask_ratio_observed)[:, None, None]
263
+ ).to(embeddings.dtype)
264
+
265
+ if self.position_embedding_type == "absolute":
266
+ position_embeddings = self.position_embeddings(position_ids)
267
+ embeddings += position_embeddings
268
+
269
+ if self.layer_norm is not None:
270
+ embeddings = self.layer_norm(embeddings)
271
+ if attention_mask is not None:
272
+ embeddings = (embeddings * attention_mask.unsqueeze(-1)).to(
273
+ embeddings.dtype
274
+ )
275
+ # Matt: I think this line was copied incorrectly from BERT, disabling it for now.
276
+ # embeddings = self.dropout(embeddings)
277
+ return embeddings
278
+
279
+ def create_position_ids_from_inputs_embeds(self, inputs_embeds):
280
+ """
281
+ We are provided embeddings directly. We cannot infer which are padded so just generate sequential position ids.
282
+
283
+ Args:
284
+ inputs_embeds: torch.Tensor
285
+
286
+ Returns: torch.Tensor
287
+ """
288
+ input_shape = inputs_embeds.size()[:-1]
289
+ sequence_length = input_shape[1]
290
+
291
+ position_ids = torch.arange(
292
+ self.padding_idx + 1,
293
+ sequence_length + self.padding_idx + 1,
294
+ dtype=torch.long,
295
+ device=inputs_embeds.device,
296
+ )
297
+ return position_ids.unsqueeze(0).expand(input_shape)
298
+
299
+
300
+ class EsmSelfAttention(nn.Module):
301
+ def __init__(self, config, position_embedding_type=None):
302
+ super().__init__()
303
+ if config.hidden_size % config.num_attention_heads != 0 and not hasattr(
304
+ config, "embedding_size"
305
+ ):
306
+ raise ValueError(
307
+ f"The hidden size ({config.hidden_size}) is not a multiple of the number of attention "
308
+ f"heads ({config.num_attention_heads})"
309
+ )
310
+
311
+ self.num_attention_heads = config.num_attention_heads
312
+ self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
313
+ self.all_head_size = self.num_attention_heads * self.attention_head_size
314
+
315
+ self.query = nn.Linear(config.hidden_size, self.all_head_size)
316
+ self.key = nn.Linear(config.hidden_size, self.all_head_size)
317
+ self.value = nn.Linear(config.hidden_size, self.all_head_size)
318
+
319
+ self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
320
+ self.position_embedding_type = position_embedding_type or getattr(
321
+ config, "position_embedding_type", "absolute"
322
+ )
323
+ self.rotary_embeddings = None
324
+ if (
325
+ self.position_embedding_type == "relative_key"
326
+ or self.position_embedding_type == "relative_key_query"
327
+ ):
328
+ self.max_position_embeddings = config.max_position_embeddings
329
+ self.distance_embedding = nn.Embedding(
330
+ 2 * config.max_position_embeddings - 1, self.attention_head_size
331
+ )
332
+ elif self.position_embedding_type == "rotary":
333
+ self.rotary_embeddings = RotaryEmbedding(dim=self.attention_head_size)
334
+
335
+ self.is_decoder = config.is_decoder
336
+
337
+ def transpose_for_scores(self, x: torch.Tensor) -> torch.Tensor:
338
+ new_x_shape = x.size()[:-1] + (
339
+ self.num_attention_heads,
340
+ self.attention_head_size,
341
+ )
342
+ x = x.view(new_x_shape)
343
+ return x.permute(0, 2, 1, 3)
344
+
345
+ def forward(
346
+ self,
347
+ hidden_states: torch.Tensor,
348
+ attention_mask: Optional[torch.FloatTensor] = None,
349
+ head_mask: Optional[torch.FloatTensor] = None,
350
+ encoder_hidden_states: Optional[torch.FloatTensor] = None,
351
+ encoder_attention_mask: Optional[torch.FloatTensor] = None,
352
+ past_key_value: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,
353
+ output_attentions: Optional[bool] = False,
354
+ ) -> Tuple[torch.Tensor]:
355
+ mixed_query_layer = self.query(hidden_states)
356
+
357
+ # If this is instantiated as a cross-attention module, the keys
358
+ # and values come from an encoder; the attention mask needs to be
359
+ # such that the encoder's padding tokens are not attended to.
360
+ is_cross_attention = encoder_hidden_states is not None
361
+
362
+ if is_cross_attention and past_key_value is not None:
363
+ # reuse k,v, cross_attentions
364
+ key_layer = past_key_value[0]
365
+ value_layer = past_key_value[1]
366
+ attention_mask = encoder_attention_mask
367
+ elif is_cross_attention:
368
+ key_layer = self.transpose_for_scores(self.key(encoder_hidden_states))
369
+ value_layer = self.transpose_for_scores(self.value(encoder_hidden_states))
370
+ attention_mask = encoder_attention_mask
371
+ elif past_key_value is not None:
372
+ key_layer = self.transpose_for_scores(self.key(hidden_states))
373
+ value_layer = self.transpose_for_scores(self.value(hidden_states))
374
+ key_layer = torch.cat([past_key_value[0], key_layer], dim=2)
375
+ value_layer = torch.cat([past_key_value[1], value_layer], dim=2)
376
+ else:
377
+ key_layer = self.transpose_for_scores(self.key(hidden_states))
378
+ value_layer = self.transpose_for_scores(self.value(hidden_states))
379
+
380
+ query_layer = self.transpose_for_scores(mixed_query_layer)
381
+
382
+ # Matt: Our BERT model (which this code was derived from) scales attention logits down by sqrt(head_dim).
383
+ # ESM scales the query down by the same factor instead. Modulo numerical stability these are equivalent,
384
+ # but not when rotary embeddings get involved. Therefore, we scale the query here to match the original
385
+ # ESM code and fix rotary embeddings.
386
+ query_layer = query_layer * self.attention_head_size**-0.5
387
+
388
+ if self.is_decoder:
389
+ # if cross_attention save Tuple(torch.Tensor, torch.Tensor) of all cross attention key/value_states.
390
+ # Further calls to cross_attention layer can then reuse all cross-attention
391
+ # key/value_states (first "if" case)
392
+ # if uni-directional self-attention (decoder) save Tuple(torch.Tensor, torch.Tensor) of
393
+ # all previous decoder key/value_states. Further calls to uni-directional self-attention
394
+ # can concat previous decoder key/value_states to current projected key/value_states (third "elif" case)
395
+ # if encoder bi-directional self-attention `past_key_value` is always `None`
396
+ past_key_value = (key_layer, value_layer)
397
+
398
+ if self.position_embedding_type == "rotary":
399
+ query_layer, key_layer = self.rotary_embeddings(query_layer, key_layer)
400
+
401
+ # Take the dot product between "query" and "key" to get the raw attention scores.
402
+ attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
403
+
404
+ if (
405
+ self.position_embedding_type == "relative_key"
406
+ or self.position_embedding_type == "relative_key_query"
407
+ ):
408
+ seq_length = hidden_states.size()[1]
409
+ position_ids_l = torch.arange(
410
+ seq_length, dtype=torch.long, device=hidden_states.device
411
+ ).view(-1, 1)
412
+ position_ids_r = torch.arange(
413
+ seq_length, dtype=torch.long, device=hidden_states.device
414
+ ).view(1, -1)
415
+ distance = position_ids_l - position_ids_r
416
+ positional_embedding = self.distance_embedding(
417
+ distance + self.max_position_embeddings - 1
418
+ )
419
+ positional_embedding = positional_embedding.to(
420
+ dtype=query_layer.dtype
421
+ ) # fp16 compatibility
422
+
423
+ if self.position_embedding_type == "relative_key":
424
+ relative_position_scores = torch.einsum(
425
+ "bhld,lrd->bhlr", query_layer, positional_embedding
426
+ )
427
+ attention_scores = attention_scores + relative_position_scores
428
+ elif self.position_embedding_type == "relative_key_query":
429
+ relative_position_scores_query = torch.einsum(
430
+ "bhld,lrd->bhlr", query_layer, positional_embedding
431
+ )
432
+ relative_position_scores_key = torch.einsum(
433
+ "bhrd,lrd->bhlr", key_layer, positional_embedding
434
+ )
435
+ attention_scores = (
436
+ attention_scores
437
+ + relative_position_scores_query
438
+ + relative_position_scores_key
439
+ )
440
+
441
+ if attention_mask is not None:
442
+ # Apply the attention mask is (precomputed for all layers in EsmModel forward() function)
443
+ attention_scores = attention_scores + attention_mask
444
+
445
+ # Normalize the attention scores to probabilities.
446
+ attention_probs = nn.functional.softmax(attention_scores, dim=-1)
447
+
448
+ # This is actually dropping out entire tokens to attend to, which might
449
+ # seem a bit unusual, but is taken from the original Transformer paper.
450
+ attention_probs = self.dropout(attention_probs)
451
+
452
+ # Mask heads if we want to
453
+ if head_mask is not None:
454
+ attention_probs = attention_probs * head_mask
455
+
456
+ context_layer = torch.matmul(attention_probs, value_layer)
457
+
458
+ context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
459
+ new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
460
+ context_layer = context_layer.view(new_context_layer_shape)
461
+
462
+ outputs = (
463
+ (context_layer, attention_probs) if output_attentions else (context_layer,)
464
+ )
465
+
466
+ if self.is_decoder:
467
+ outputs = outputs + (past_key_value,)
468
+ return outputs
469
+
470
+
471
+ class EsmSelfOutput(nn.Module):
472
+ def __init__(self, config):
473
+ super().__init__()
474
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
475
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
476
+
477
+ def forward(self, hidden_states, input_tensor):
478
+ hidden_states = self.dense(hidden_states)
479
+ hidden_states = self.dropout(hidden_states)
480
+ hidden_states += input_tensor
481
+ return hidden_states
482
+
483
+
484
+ class EsmAttention(nn.Module):
485
+ def __init__(self, config):
486
+ super().__init__()
487
+ self.self = EsmSelfAttention(config)
488
+ self.output = EsmSelfOutput(config)
489
+ self.pruned_heads = set()
490
+ self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
491
+
492
+ def prune_heads(self, heads):
493
+ if len(heads) == 0:
494
+ return
495
+ heads, index = find_pruneable_heads_and_indices(
496
+ heads,
497
+ self.self.num_attention_heads,
498
+ self.self.attention_head_size,
499
+ self.pruned_heads,
500
+ )
501
+
502
+ # Prune linear layers
503
+ self.self.query = prune_linear_layer(self.self.query, index)
504
+ self.self.key = prune_linear_layer(self.self.key, index)
505
+ self.self.value = prune_linear_layer(self.self.value, index)
506
+ self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
507
+
508
+ # Update hyper params and store pruned heads
509
+ self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
510
+ self.self.all_head_size = (
511
+ self.self.attention_head_size * self.self.num_attention_heads
512
+ )
513
+ self.pruned_heads = self.pruned_heads.union(heads)
514
+
515
+ def forward(
516
+ self,
517
+ hidden_states,
518
+ attention_mask=None,
519
+ head_mask=None,
520
+ encoder_hidden_states=None,
521
+ encoder_attention_mask=None,
522
+ past_key_value=None,
523
+ output_attentions=False,
524
+ ):
525
+ hidden_states_ln = self.LayerNorm(hidden_states)
526
+ self_outputs = self.self(
527
+ hidden_states_ln,
528
+ attention_mask,
529
+ head_mask,
530
+ encoder_hidden_states,
531
+ encoder_attention_mask,
532
+ past_key_value,
533
+ output_attentions,
534
+ )
535
+ attention_output = self.output(self_outputs[0], hidden_states)
536
+ outputs = (attention_output,) + self_outputs[
537
+ 1:
538
+ ] # add attentions if we output them
539
+ return outputs
540
+
541
+
542
+ class EsmIntermediate(nn.Module):
543
+ def __init__(self, config):
544
+ super().__init__()
545
+
546
+ self.dense = nn.Linear(
547
+ config.hidden_size,
548
+ int(config.intermediate_size * 2),
549
+ bias=config.add_bias_fnn,
550
+ )
551
+ self.activation_fn = SiLU()
552
+
553
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
554
+ hidden_states = self.dense(hidden_states)
555
+
556
+ # GLU
557
+ x1, x2 = hidden_states.split(int(hidden_states.size(-1) / 2), -1)
558
+ hidden_states = self.activation_fn(x1) * x2
559
+
560
+ return hidden_states
561
+
562
+
563
+ class EsmOutput(nn.Module):
564
+ def __init__(self, config):
565
+ super().__init__()
566
+ self.dense = nn.Linear(
567
+ config.intermediate_size, config.hidden_size, bias=config.add_bias_fnn
568
+ )
569
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
570
+
571
+ def forward(self, hidden_states, input_tensor):
572
+ hidden_states = self.dense(hidden_states)
573
+ hidden_states = self.dropout(hidden_states)
574
+ hidden_states += input_tensor
575
+ return hidden_states
576
+
577
+
578
+ class EsmLayer(nn.Module):
579
+ def __init__(self, config):
580
+ super().__init__()
581
+ self.chunk_size_feed_forward = config.chunk_size_feed_forward
582
+ self.seq_len_dim = 1
583
+ self.attention = EsmAttention(config)
584
+ self.is_decoder = config.is_decoder
585
+ self.add_cross_attention = config.add_cross_attention
586
+ if self.add_cross_attention:
587
+ if not self.is_decoder:
588
+ raise RuntimeError(
589
+ f"{self} should be used as a decoder model if cross attention is added"
590
+ )
591
+ self.crossattention = EsmAttention(config)
592
+ self.intermediate = EsmIntermediate(config)
593
+ self.output = EsmOutput(config)
594
+ self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
595
+
596
+ def forward(
597
+ self,
598
+ hidden_states,
599
+ attention_mask=None,
600
+ head_mask=None,
601
+ encoder_hidden_states=None,
602
+ encoder_attention_mask=None,
603
+ past_key_value=None,
604
+ output_attentions=False,
605
+ ):
606
+ # decoder uni-directional self-attention cached key/values tuple is at positions 1,2
607
+ self_attn_past_key_value = (
608
+ past_key_value[:2] if past_key_value is not None else None
609
+ )
610
+ self_attention_outputs = self.attention(
611
+ hidden_states,
612
+ attention_mask,
613
+ head_mask,
614
+ output_attentions=output_attentions,
615
+ past_key_value=self_attn_past_key_value,
616
+ )
617
+ attention_output = self_attention_outputs[0]
618
+
619
+ # if decoder, the last output is tuple of self-attn cache
620
+ if self.is_decoder:
621
+ outputs = self_attention_outputs[1:-1]
622
+ present_key_value = self_attention_outputs[-1]
623
+ else:
624
+ outputs = self_attention_outputs[
625
+ 1:
626
+ ] # add self attentions if we output attention weights
627
+
628
+ cross_attn_present_key_value = None
629
+ if self.is_decoder and encoder_hidden_states is not None:
630
+ if not hasattr(self, "crossattention"):
631
+ raise AttributeError(
632
+ f"If `encoder_hidden_states` are passed, {self} has to be instantiated"
633
+ " with cross-attention layers by setting `config.add_cross_attention=True`"
634
+ )
635
+
636
+ # cross_attn cached key/values tuple is at positions 3,4 of past_key_value tuple
637
+ cross_attn_past_key_value = (
638
+ past_key_value[-2:] if past_key_value is not None else None
639
+ )
640
+ cross_attention_outputs = self.crossattention(
641
+ attention_output,
642
+ attention_mask,
643
+ head_mask,
644
+ encoder_hidden_states,
645
+ encoder_attention_mask,
646
+ cross_attn_past_key_value,
647
+ output_attentions,
648
+ )
649
+ attention_output = cross_attention_outputs[0]
650
+ outputs = (
651
+ outputs + cross_attention_outputs[1:-1]
652
+ ) # add cross attentions if we output attention weights
653
+
654
+ # add cross-attn cache to positions 3,4 of present_key_value tuple
655
+ cross_attn_present_key_value = cross_attention_outputs[-1]
656
+ present_key_value = present_key_value + cross_attn_present_key_value
657
+
658
+ layer_output = self.feed_forward_chunk(attention_output)
659
+
660
+ outputs = (layer_output,) + outputs
661
+
662
+ # if decoder, return the attn key/values as the last output
663
+ if self.is_decoder:
664
+ outputs = outputs + (present_key_value,)
665
+ return outputs
666
+
667
+ def feed_forward_chunk(self, attention_output):
668
+ attention_output_ln = self.LayerNorm(attention_output)
669
+ intermediate_output = self.intermediate(attention_output_ln)
670
+ layer_output = self.output(intermediate_output, attention_output)
671
+ return layer_output
672
+
673
+
674
+ class EsmEncoder(nn.Module):
675
+ def __init__(self, config):
676
+ super().__init__()
677
+ self.config = config
678
+ self.layer = nn.ModuleList(
679
+ [EsmLayer(config) for _ in range(config.num_hidden_layers)]
680
+ )
681
+ self.emb_layer_norm_after = nn.LayerNorm(
682
+ config.hidden_size, eps=config.layer_norm_eps
683
+ )
684
+ self.gradient_checkpointing = False
685
+
686
+ def forward(
687
+ self,
688
+ hidden_states,
689
+ attention_mask=None,
690
+ head_mask=None,
691
+ encoder_hidden_states=None,
692
+ encoder_attention_mask=None,
693
+ past_key_values=None,
694
+ use_cache=None,
695
+ output_attentions=False,
696
+ output_hidden_states=False,
697
+ return_dict=True,
698
+ ):
699
+ if self.gradient_checkpointing and self.training:
700
+ if use_cache:
701
+ logger.warning_once(
702
+ "`use_cache=True` is incompatible with `config.gradient_checkpointing=True`. Setting "
703
+ "`use_cache=False`..."
704
+ )
705
+ use_cache = False
706
+ all_hidden_states = () if output_hidden_states else None
707
+ all_self_attentions = () if output_attentions else None
708
+ all_cross_attentions = (
709
+ () if output_attentions and self.config.add_cross_attention else None
710
+ )
711
+
712
+ next_decoder_cache = () if use_cache else None
713
+ for i, layer_module in enumerate(self.layer):
714
+ if output_hidden_states:
715
+ all_hidden_states = all_hidden_states + (hidden_states,)
716
+
717
+ layer_head_mask = head_mask[i] if head_mask is not None else None
718
+ past_key_value = past_key_values[i] if past_key_values is not None else None
719
+
720
+ if self.gradient_checkpointing and self.training:
721
+
722
+ def create_custom_forward(module):
723
+ def custom_forward(*inputs):
724
+ return module(*inputs, past_key_value, output_attentions)
725
+
726
+ return custom_forward
727
+
728
+ layer_outputs = torch.utils.checkpoint.checkpoint(
729
+ create_custom_forward(layer_module),
730
+ hidden_states,
731
+ attention_mask,
732
+ layer_head_mask,
733
+ encoder_hidden_states,
734
+ encoder_attention_mask,
735
+ )
736
+ else:
737
+ layer_outputs = layer_module(
738
+ hidden_states,
739
+ attention_mask,
740
+ layer_head_mask,
741
+ encoder_hidden_states,
742
+ encoder_attention_mask,
743
+ past_key_value,
744
+ output_attentions,
745
+ )
746
+
747
+ hidden_states = layer_outputs[0]
748
+ if use_cache:
749
+ next_decoder_cache += (layer_outputs[-1],)
750
+ if output_attentions:
751
+ all_self_attentions = all_self_attentions + (layer_outputs[1],)
752
+ if self.config.add_cross_attention:
753
+ all_cross_attentions = all_cross_attentions + (layer_outputs[2],)
754
+
755
+ if self.emb_layer_norm_after:
756
+ hidden_states = self.emb_layer_norm_after(hidden_states)
757
+
758
+ if output_hidden_states:
759
+ all_hidden_states = all_hidden_states + (hidden_states,)
760
+
761
+ if not return_dict:
762
+ return tuple(
763
+ v
764
+ for v in [
765
+ hidden_states,
766
+ next_decoder_cache,
767
+ all_hidden_states,
768
+ all_self_attentions,
769
+ all_cross_attentions,
770
+ ]
771
+ if v is not None
772
+ )
773
+ return BaseModelOutputWithPastAndCrossAttentions(
774
+ last_hidden_state=hidden_states,
775
+ past_key_values=next_decoder_cache,
776
+ hidden_states=all_hidden_states,
777
+ attentions=all_self_attentions,
778
+ cross_attentions=all_cross_attentions,
779
+ )
780
+
781
+
782
+ # Copied from transformers.models.bert.modeling_bert.BertPooler
783
+ class EsmPooler(nn.Module):
784
+ def __init__(self, config):
785
+ super().__init__()
786
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
787
+ self.activation = nn.Tanh()
788
+
789
+ def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
790
+ # We "pool" the model by simply taking the hidden state corresponding
791
+ # to the first token.
792
+ first_token_tensor = hidden_states[:, 0]
793
+ pooled_output = self.dense(first_token_tensor)
794
+ pooled_output = self.activation(pooled_output)
795
+ return pooled_output
796
+
797
+
798
+ class EsmPreTrainedModel(PreTrainedModel):
799
+ """
800
+ An abstract class to handle weights initialization and a simple interface for downloading and loading pretrained
801
+ models.
802
+ """
803
+
804
+ config_class = EsmConfig
805
+ base_model_prefix = "esm"
806
+ _no_split_modules = ["EsmLayer", "EsmFoldTriangularSelfAttentionBlock"]
807
+
808
+ # Copied from transformers.models.bert.modeling_bert.BertPreTrainedModel._init_weights
809
+ def _init_weights(self, module):
810
+ """Initialize the weights"""
811
+ if isinstance(module, nn.Linear):
812
+ # Slightly different from the TF version which uses truncated_normal for initialization
813
+ # cf https://github.com/pytorch/pytorch/pull/5617
814
+ module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
815
+ if module.bias is not None:
816
+ module.bias.data.zero_()
817
+ elif isinstance(module, nn.Embedding):
818
+ module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
819
+ if module.padding_idx is not None:
820
+ module.weight.data[module.padding_idx].zero_()
821
+ elif isinstance(module, nn.LayerNorm):
822
+ module.bias.data.zero_()
823
+ module.weight.data.fill_(1.0)
824
+
825
+
826
+ ESM_START_DOCSTRING = r"""
827
+
828
+ This model inherits from [`PreTrainedModel`]. Check the superclass documentation for the generic methods the
829
+ library implements for all its model (such as downloading or saving, resizing the input embeddings, pruning heads
830
+ etc.)
831
+
832
+ This model is also a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass.
833
+ Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage
834
+ and behavior.
835
+
836
+ Parameters:
837
+ config ([`EsmConfig`]): Model configuration class with all the parameters of the
838
+ model. Initializing with a config file does not load the weights associated with the model, only the
839
+ configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
840
+ """
841
+
842
+ ESM_INPUTS_DOCSTRING = r"""
843
+ Args:
844
+ input_ids (`torch.LongTensor` of shape `({0})`):
845
+ Indices of input sequence tokens in the vocabulary.
846
+
847
+ Indices can be obtained using [`AutoTokenizer`]. See [`PreTrainedTokenizer.encode`] and
848
+ [`PreTrainedTokenizer.__call__`] for details.
849
+
850
+ [What are input IDs?](../glossary#input-ids)
851
+ attention_mask (`torch.FloatTensor` of shape `({0})`, *optional*):
852
+ Mask to avoid performing attention on padding token indices. Mask values selected in `[0, 1]`:
853
+
854
+ - 1 for tokens that are **not masked**,
855
+ - 0 for tokens that are **masked**.
856
+
857
+ [What are attention masks?](../glossary#attention-mask)
858
+ position_ids (`torch.LongTensor` of shape `({0})`, *optional*):
859
+ Indices of positions of each input sequence tokens in the position embeddings. Selected in the range `[0,
860
+ config.max_position_embeddings - 1]`.
861
+
862
+ [What are position IDs?](../glossary#position-ids)
863
+ head_mask (`torch.FloatTensor` of shape `(num_heads,)` or `(num_layers, num_heads)`, *optional*):
864
+ Mask to nullify selected heads of the self-attention modules. Mask values selected in `[0, 1]`:
865
+
866
+ - 1 indicates the head is **not masked**,
867
+ - 0 indicates the head is **masked**.
868
+
869
+ inputs_embeds (`torch.FloatTensor` of shape `({0}, hidden_size)`, *optional*):
870
+ Optionally, instead of passing `input_ids` you can choose to directly pass an embedded representation. This
871
+ is useful if you want more control over how to convert `input_ids` indices into associated vectors than the
872
+ model's internal embedding lookup matrix.
873
+ output_attentions (`bool`, *optional*):
874
+ Whether or not to return the attentions tensors of all attention layers. See `attentions` under returned
875
+ tensors for more detail.
876
+ output_hidden_states (`bool`, *optional*):
877
+ Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
878
+ more detail.
879
+ return_dict (`bool`, *optional*):
880
+ Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.
881
+ """
882
+
883
+
884
+ @add_start_docstrings(
885
+ "The bare ESM Model transformer outputting raw hidden-states without any specific head on top.",
886
+ ESM_START_DOCSTRING,
887
+ )
888
+ class EsmModel(EsmPreTrainedModel):
889
+ """
890
+
891
+ The model can behave as an encoder (with only self-attention) as well as a decoder, in which case a layer of
892
+ cross-attention is added between the self-attention layers, following the architecture described in [Attention is
893
+ all you need](https://arxiv.org/abs/1706.03762) by Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit,
894
+ Llion Jones, Aidan N. Gomez, Lukasz Kaiser and Illia Polosukhin.
895
+
896
+ To behave as an decoder the model needs to be initialized with the `is_decoder` argument of the configuration set
897
+ to `True`. To be used in a Seq2Seq model, the model needs to initialized with both `is_decoder` argument and
898
+ `add_cross_attention` set to `True`; an `encoder_hidden_states` is then expected as an input to the forward pass.
899
+ """
900
+
901
+ supports_gradient_checkpointing = False
902
+
903
+ def __init__(self, config, add_pooling_layer=True):
904
+ super().__init__(config)
905
+ self.config = config
906
+
907
+ self.embeddings = EsmEmbeddings(config)
908
+ self.encoder = EsmEncoder(config)
909
+
910
+ self.pooler = EsmPooler(config) if add_pooling_layer else None
911
+
912
+ self.contact_head = EsmContactPredictionHead(
913
+ in_features=config.num_hidden_layers * config.num_attention_heads, bias=True
914
+ )
915
+
916
+ # Initialize weights and apply final processing
917
+ self.post_init()
918
+
919
+ def _set_gradient_checkpointing(self, module, value=False):
920
+ if isinstance(module, EsmEncoder):
921
+ module.gradient_checkpointing = value
922
+
923
+ def get_input_embeddings(self):
924
+ return self.embeddings.word_embeddings
925
+
926
+ def set_input_embeddings(self, value):
927
+ self.embeddings.word_embeddings = value
928
+
929
+ def _prune_heads(self, heads_to_prune):
930
+ """
931
+ Prunes heads of the model. heads_to_prune: dict of {layer_num: list of heads to prune in this layer} See base
932
+ class PreTrainedModel
933
+ """
934
+ for layer, heads in heads_to_prune.items():
935
+ self.encoder.layer[layer].attention.prune_heads(heads)
936
+
937
+ @add_start_docstrings_to_model_forward(
938
+ ESM_INPUTS_DOCSTRING.format("(batch_size, sequence_length)")
939
+ )
940
+ @add_code_sample_docstrings(
941
+ checkpoint=_CHECKPOINT_FOR_DOC,
942
+ output_type=BaseModelOutputWithPoolingAndCrossAttentions,
943
+ config_class=_CONFIG_FOR_DOC,
944
+ )
945
+ def forward(
946
+ self,
947
+ input_ids: Optional[torch.Tensor] = None,
948
+ attention_mask: Optional[torch.Tensor] = None,
949
+ position_ids: Optional[torch.Tensor] = None,
950
+ head_mask: Optional[torch.Tensor] = None,
951
+ inputs_embeds: Optional[torch.Tensor] = None,
952
+ encoder_hidden_states: Optional[torch.Tensor] = None,
953
+ encoder_attention_mask: Optional[torch.Tensor] = None,
954
+ past_key_values: Optional[List[torch.FloatTensor]] = None,
955
+ use_cache: Optional[bool] = None,
956
+ output_attentions: Optional[bool] = None,
957
+ output_hidden_states: Optional[bool] = None,
958
+ return_dict: Optional[bool] = None,
959
+ ) -> Union[Tuple[torch.Tensor], BaseModelOutputWithPoolingAndCrossAttentions]:
960
+ r"""
961
+ encoder_hidden_states (`torch.FloatTensor` of shape `(batch_size, sequence_length, hidden_size)`, *optional*):
962
+ Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention if
963
+ the model is configured as a decoder.
964
+ encoder_attention_mask (`torch.FloatTensor` of shape `(batch_size, sequence_length)`, *optional*):
965
+ Mask to avoid performing attention on the padding token indices of the encoder input. This mask is used in
966
+ the cross-attention if the model is configured as a decoder. Mask values selected in `[0, 1]`:
967
+
968
+ - 1 for tokens that are **not masked**,
969
+ - 0 for tokens that are **masked**.
970
+ past_key_values (`tuple(tuple(torch.FloatTensor))` of length `config.n_layers` with each tuple having 4 tensors of shape `(batch_size, num_heads, sequence_length - 1, embed_size_per_head)`):
971
+ Contains precomputed key and value hidden states of the attention blocks. Can be used to speed up decoding.
972
+
973
+ If `past_key_values` are used, the user can optionally input only the last `decoder_input_ids` (those that
974
+ don't have their past key value states given to this model) of shape `(batch_size, 1)` instead of all
975
+ `decoder_input_ids` of shape `(batch_size, sequence_length)`.
976
+ use_cache (`bool`, *optional*):
977
+ If set to `True`, `past_key_values` key value states are returned and can be used to speed up decoding (see
978
+ `past_key_values`).
979
+ """
980
+ output_attentions = (
981
+ output_attentions
982
+ if output_attentions is not None
983
+ else self.config.output_attentions
984
+ )
985
+ output_hidden_states = (
986
+ output_hidden_states
987
+ if output_hidden_states is not None
988
+ else self.config.output_hidden_states
989
+ )
990
+ return_dict = (
991
+ return_dict if return_dict is not None else self.config.use_return_dict
992
+ )
993
+
994
+ if self.config.is_decoder:
995
+ use_cache = use_cache if use_cache is not None else self.config.use_cache
996
+ else:
997
+ use_cache = False
998
+
999
+ if input_ids is not None and inputs_embeds is not None:
1000
+ raise ValueError(
1001
+ "You cannot specify both input_ids and inputs_embeds at the same time"
1002
+ )
1003
+ elif input_ids is not None:
1004
+ input_shape = input_ids.size()
1005
+ elif inputs_embeds is not None:
1006
+ input_shape = inputs_embeds.size()[:-1]
1007
+ else:
1008
+ raise ValueError("You have to specify either input_ids or inputs_embeds")
1009
+
1010
+ batch_size, seq_length = input_shape
1011
+ device = input_ids.device if input_ids is not None else inputs_embeds.device
1012
+
1013
+ # past_key_values_length
1014
+ past_key_values_length = (
1015
+ past_key_values[0][0].shape[2] if past_key_values is not None else 0
1016
+ )
1017
+
1018
+ if attention_mask is None:
1019
+ attention_mask = torch.ones(
1020
+ ((batch_size, seq_length + past_key_values_length)), device=device
1021
+ )
1022
+
1023
+ # We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length]
1024
+ # ourselves in which case we just need to make it broadcastable to all heads.
1025
+ extended_attention_mask: torch.Tensor = self.get_extended_attention_mask(
1026
+ attention_mask, input_shape
1027
+ )
1028
+
1029
+ # If a 2D or 3D attention mask is provided for the cross-attention
1030
+ # we need to make broadcastable to [batch_size, num_heads, seq_length, seq_length]
1031
+ if self.config.is_decoder and encoder_hidden_states is not None:
1032
+ (
1033
+ encoder_batch_size,
1034
+ encoder_sequence_length,
1035
+ _,
1036
+ ) = encoder_hidden_states.size()
1037
+ encoder_hidden_shape = (encoder_batch_size, encoder_sequence_length)
1038
+ if encoder_attention_mask is None:
1039
+ encoder_attention_mask = torch.ones(encoder_hidden_shape, device=device)
1040
+ encoder_extended_attention_mask = self.invert_attention_mask(
1041
+ encoder_attention_mask
1042
+ )
1043
+ else:
1044
+ encoder_extended_attention_mask = None
1045
+
1046
+ # Prepare head mask if needed
1047
+ # 1.0 in head_mask indicate we keep the head
1048
+ # attention_probs has shape bsz x n_heads x N x N
1049
+ # input head_mask has shape [num_heads] or [num_hidden_layers x num_heads]
1050
+ # and head_mask is converted to shape [num_hidden_layers x batch x num_heads x seq_length x seq_length]
1051
+ head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
1052
+
1053
+ embedding_output = self.embeddings(
1054
+ input_ids=input_ids,
1055
+ position_ids=position_ids,
1056
+ attention_mask=attention_mask,
1057
+ inputs_embeds=inputs_embeds,
1058
+ past_key_values_length=past_key_values_length,
1059
+ )
1060
+ encoder_outputs = self.encoder(
1061
+ embedding_output,
1062
+ attention_mask=extended_attention_mask,
1063
+ head_mask=head_mask,
1064
+ encoder_hidden_states=encoder_hidden_states,
1065
+ encoder_attention_mask=encoder_extended_attention_mask,
1066
+ past_key_values=past_key_values,
1067
+ use_cache=use_cache,
1068
+ output_attentions=output_attentions,
1069
+ output_hidden_states=output_hidden_states,
1070
+ return_dict=return_dict,
1071
+ )
1072
+ sequence_output = encoder_outputs[0]
1073
+ pooled_output = (
1074
+ self.pooler(sequence_output) if self.pooler is not None else None
1075
+ )
1076
+
1077
+ if not return_dict:
1078
+ return (sequence_output, pooled_output) + encoder_outputs[1:]
1079
+
1080
+ return BaseModelOutputWithPoolingAndCrossAttentions(
1081
+ last_hidden_state=sequence_output,
1082
+ pooler_output=pooled_output,
1083
+ past_key_values=encoder_outputs.past_key_values,
1084
+ hidden_states=encoder_outputs.hidden_states,
1085
+ attentions=encoder_outputs.attentions,
1086
+ cross_attentions=encoder_outputs.cross_attentions,
1087
+ )
1088
+
1089
+ def predict_contacts(self, tokens, attention_mask):
1090
+ attns = self(
1091
+ tokens,
1092
+ attention_mask=attention_mask,
1093
+ return_dict=True,
1094
+ output_attentions=True,
1095
+ ).attentions
1096
+ attns = torch.stack(attns, dim=1) # Matches the original model layout
1097
+ # In the original model, attentions for padding tokens are completely zeroed out.
1098
+ # This makes no difference most of the time because the other tokens won't attend to them,
1099
+ # but it does for the contact prediction task, which takes attentions as input,
1100
+ # so we have to mimic that here.
1101
+ attns *= attention_mask.unsqueeze(1).unsqueeze(2).unsqueeze(3)
1102
+ attns *= attention_mask.unsqueeze(1).unsqueeze(2).unsqueeze(4)
1103
+ return self.contact_head(tokens, attns)
1104
+
1105
+
1106
+ @add_start_docstrings(
1107
+ """ESM Model with a `language modeling` head on top.""", ESM_START_DOCSTRING
1108
+ )
1109
+ class EsmForMaskedLM(EsmPreTrainedModel):
1110
+ _tied_weights_keys = ["lm_head.decoder.weight"]
1111
+
1112
+ def __init__(self, config):
1113
+ super().__init__(config)
1114
+
1115
+ if config.is_decoder:
1116
+ logger.warning(
1117
+ "If you want to use `EsmForMaskedLM` make sure `config.is_decoder=False` for "
1118
+ "bi-directional self-attention."
1119
+ )
1120
+
1121
+ self.esm = EsmModel(config, add_pooling_layer=False)
1122
+ self.lm_head = EsmLMHead(config)
1123
+
1124
+ self.init_weights()
1125
+
1126
+ def get_output_embeddings(self):
1127
+ return self.lm_head.decoder
1128
+
1129
+ def set_output_embeddings(self, new_embeddings):
1130
+ self.lm_head.decoder = new_embeddings
1131
+
1132
+ @add_start_docstrings_to_model_forward(
1133
+ ESM_INPUTS_DOCSTRING.format("batch_size, sequence_length")
1134
+ )
1135
+ @add_code_sample_docstrings(
1136
+ checkpoint=_CHECKPOINT_FOR_DOC,
1137
+ output_type=MaskedLMOutput,
1138
+ config_class=_CONFIG_FOR_DOC,
1139
+ mask="<mask>",
1140
+ )
1141
+ def forward(
1142
+ self,
1143
+ input_ids: Optional[torch.LongTensor] = None,
1144
+ attention_mask: Optional[torch.Tensor] = None,
1145
+ position_ids: Optional[torch.LongTensor] = None,
1146
+ head_mask: Optional[torch.Tensor] = None,
1147
+ inputs_embeds: Optional[torch.FloatTensor] = None,
1148
+ encoder_hidden_states: Optional[torch.FloatTensor] = None,
1149
+ encoder_attention_mask: Optional[torch.Tensor] = None,
1150
+ labels: Optional[torch.LongTensor] = None,
1151
+ output_attentions: Optional[bool] = None,
1152
+ output_hidden_states: Optional[bool] = None,
1153
+ return_dict: Optional[bool] = None,
1154
+ ) -> Union[Tuple, MaskedLMOutput]:
1155
+ r"""
1156
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
1157
+ Labels for computing the masked language modeling loss. Indices should be in `[-100, 0, ...,
1158
+ config.vocab_size]` (see `input_ids` docstring) Tokens with indices set to `-100` are ignored (masked), the
1159
+ loss is only computed for the tokens with labels in `[0, ..., config.vocab_size]`
1160
+ kwargs (`Dict[str, any]`, optional, defaults to *{}*):
1161
+ Used to hide legacy arguments that have been deprecated.
1162
+ """
1163
+ return_dict = (
1164
+ return_dict if return_dict is not None else self.config.use_return_dict
1165
+ )
1166
+
1167
+ outputs = self.esm(
1168
+ input_ids,
1169
+ attention_mask=attention_mask,
1170
+ position_ids=position_ids,
1171
+ head_mask=head_mask,
1172
+ inputs_embeds=inputs_embeds,
1173
+ encoder_hidden_states=encoder_hidden_states,
1174
+ encoder_attention_mask=encoder_attention_mask,
1175
+ output_attentions=output_attentions,
1176
+ output_hidden_states=output_hidden_states,
1177
+ return_dict=return_dict,
1178
+ )
1179
+ sequence_output = outputs[0]
1180
+ prediction_scores = self.lm_head(sequence_output)
1181
+
1182
+ masked_lm_loss = None
1183
+ if labels is not None:
1184
+ loss_fct = CrossEntropyLoss()
1185
+
1186
+ labels = labels.to(prediction_scores.device)
1187
+ masked_lm_loss = loss_fct(
1188
+ prediction_scores.view(-1, self.config.vocab_size), labels.view(-1)
1189
+ )
1190
+
1191
+ if not return_dict:
1192
+ output = (prediction_scores,) + outputs[2:]
1193
+ return (
1194
+ ((masked_lm_loss,) + output) if masked_lm_loss is not None else output
1195
+ )
1196
+
1197
+ return MaskedLMOutput(
1198
+ loss=masked_lm_loss,
1199
+ logits=prediction_scores,
1200
+ hidden_states=outputs.hidden_states,
1201
+ attentions=outputs.attentions,
1202
+ )
1203
+
1204
+ def predict_contacts(self, tokens, attention_mask):
1205
+ return self.esm.predict_contacts(tokens, attention_mask=attention_mask)
1206
+
1207
+
1208
+ class EsmLMHead(nn.Module):
1209
+ """ESM Head for masked language modeling."""
1210
+
1211
+ def __init__(self, config):
1212
+ super().__init__()
1213
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
1214
+ self.layer_norm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
1215
+
1216
+ self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
1217
+ self.bias = nn.Parameter(torch.zeros(config.vocab_size))
1218
+
1219
+ def forward(self, features, **kwargs):
1220
+ x = self.dense(features)
1221
+ x = gelu(x)
1222
+ x = self.layer_norm(x)
1223
+
1224
+ # project back to size of vocabulary with bias
1225
+ x = self.decoder(x) + self.bias
1226
+ return x
1227
+
1228
+
1229
+ @add_start_docstrings(
1230
+ """
1231
+ ESM Model transformer with a sequence classification/regression head on top (a linear layer on top of the pooled
1232
+ output) e.g. for GLUE tasks.
1233
+ """,
1234
+ ESM_START_DOCSTRING,
1235
+ )
1236
+ class EsmForSequenceClassification(EsmPreTrainedModel):
1237
+ def __init__(self, config):
1238
+ super().__init__(config)
1239
+ self.num_labels = config.num_labels
1240
+ self.config = config
1241
+
1242
+ self.esm = EsmModel(config, add_pooling_layer=False)
1243
+ self.classifier = EsmClassificationHead(config)
1244
+
1245
+ self.init_weights()
1246
+
1247
+ @add_start_docstrings_to_model_forward(
1248
+ ESM_INPUTS_DOCSTRING.format("batch_size, sequence_length")
1249
+ )
1250
+ @add_code_sample_docstrings(
1251
+ checkpoint=_CHECKPOINT_FOR_DOC,
1252
+ output_type=SequenceClassifierOutput,
1253
+ config_class=_CONFIG_FOR_DOC,
1254
+ )
1255
+ def forward(
1256
+ self,
1257
+ input_ids: Optional[torch.LongTensor] = None,
1258
+ attention_mask: Optional[torch.Tensor] = None,
1259
+ position_ids: Optional[torch.LongTensor] = None,
1260
+ head_mask: Optional[torch.Tensor] = None,
1261
+ inputs_embeds: Optional[torch.FloatTensor] = None,
1262
+ labels: Optional[torch.LongTensor] = None,
1263
+ output_attentions: Optional[bool] = None,
1264
+ output_hidden_states: Optional[bool] = None,
1265
+ return_dict: Optional[bool] = None,
1266
+ ) -> Union[Tuple, SequenceClassifierOutput]:
1267
+ r"""
1268
+ labels (`torch.LongTensor` of shape `(batch_size,)`, *optional*):
1269
+ Labels for computing the sequence classification/regression loss. Indices should be in `[0, ...,
1270
+ config.num_labels - 1]`. If `config.num_labels == 1` a regression loss is computed (Mean-Square loss), If
1271
+ `config.num_labels > 1` a classification loss is computed (Cross-Entropy).
1272
+ """
1273
+ return_dict = (
1274
+ return_dict if return_dict is not None else self.config.use_return_dict
1275
+ )
1276
+
1277
+ outputs = self.esm(
1278
+ input_ids,
1279
+ attention_mask=attention_mask,
1280
+ position_ids=position_ids,
1281
+ head_mask=head_mask,
1282
+ inputs_embeds=inputs_embeds,
1283
+ output_attentions=output_attentions,
1284
+ output_hidden_states=output_hidden_states,
1285
+ return_dict=return_dict,
1286
+ )
1287
+ sequence_output = outputs[0]
1288
+ logits = self.classifier(sequence_output)
1289
+
1290
+ loss = None
1291
+ if labels is not None:
1292
+ labels = labels.to(logits.device)
1293
+
1294
+ if self.config.problem_type is None:
1295
+ if self.num_labels == 1:
1296
+ self.config.problem_type = "regression"
1297
+ elif self.num_labels > 1 and (
1298
+ labels.dtype == torch.long or labels.dtype == torch.int
1299
+ ):
1300
+ self.config.problem_type = "single_label_classification"
1301
+ else:
1302
+ self.config.problem_type = "multi_label_classification"
1303
+
1304
+ if self.config.problem_type == "regression":
1305
+ loss_fct = MSELoss()
1306
+ if self.num_labels == 1:
1307
+ loss = loss_fct(logits.squeeze(), labels.squeeze())
1308
+ else:
1309
+ loss = loss_fct(logits, labels)
1310
+ elif self.config.problem_type == "single_label_classification":
1311
+ loss_fct = CrossEntropyLoss()
1312
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
1313
+ elif self.config.problem_type == "multi_label_classification":
1314
+ loss_fct = BCEWithLogitsLoss()
1315
+ loss = loss_fct(logits, labels)
1316
+
1317
+ if not return_dict:
1318
+ output = (logits,) + outputs[2:]
1319
+ return ((loss,) + output) if loss is not None else output
1320
+
1321
+ return SequenceClassifierOutput(
1322
+ loss=loss,
1323
+ logits=logits,
1324
+ hidden_states=outputs.hidden_states,
1325
+ attentions=outputs.attentions,
1326
+ )
1327
+
1328
+
1329
+ @add_start_docstrings(
1330
+ """
1331
+ ESM Model with a token classification head on top (a linear layer on top of the hidden-states output) e.g. for
1332
+ Named-Entity-Recognition (NER) tasks.
1333
+ """,
1334
+ ESM_START_DOCSTRING,
1335
+ )
1336
+ class EsmForTokenClassification(EsmPreTrainedModel):
1337
+ def __init__(self, config):
1338
+ super().__init__(config)
1339
+ self.num_labels = config.num_labels
1340
+
1341
+ self.esm = EsmModel(config, add_pooling_layer=False)
1342
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
1343
+ self.classifier = nn.Linear(config.hidden_size, config.num_labels)
1344
+
1345
+ self.init_weights()
1346
+
1347
+ @add_start_docstrings_to_model_forward(
1348
+ ESM_INPUTS_DOCSTRING.format("batch_size, sequence_length")
1349
+ )
1350
+ @add_code_sample_docstrings(
1351
+ checkpoint=_CHECKPOINT_FOR_DOC,
1352
+ output_type=TokenClassifierOutput,
1353
+ config_class=_CONFIG_FOR_DOC,
1354
+ )
1355
+ def forward(
1356
+ self,
1357
+ input_ids: Optional[torch.LongTensor] = None,
1358
+ attention_mask: Optional[torch.Tensor] = None,
1359
+ position_ids: Optional[torch.LongTensor] = None,
1360
+ head_mask: Optional[torch.Tensor] = None,
1361
+ inputs_embeds: Optional[torch.FloatTensor] = None,
1362
+ labels: Optional[torch.LongTensor] = None,
1363
+ output_attentions: Optional[bool] = None,
1364
+ output_hidden_states: Optional[bool] = None,
1365
+ return_dict: Optional[bool] = None,
1366
+ ) -> Union[Tuple, TokenClassifierOutput]:
1367
+ r"""
1368
+ labels (`torch.LongTensor` of shape `(batch_size, sequence_length)`, *optional*):
1369
+ Labels for computing the token classification loss. Indices should be in `[0, ..., config.num_labels - 1]`.
1370
+ """
1371
+ return_dict = (
1372
+ return_dict if return_dict is not None else self.config.use_return_dict
1373
+ )
1374
+
1375
+ outputs = self.esm(
1376
+ input_ids,
1377
+ attention_mask=attention_mask,
1378
+ position_ids=position_ids,
1379
+ head_mask=head_mask,
1380
+ inputs_embeds=inputs_embeds,
1381
+ output_attentions=output_attentions,
1382
+ output_hidden_states=output_hidden_states,
1383
+ return_dict=return_dict,
1384
+ )
1385
+
1386
+ sequence_output = outputs[0]
1387
+
1388
+ sequence_output = self.dropout(sequence_output)
1389
+ logits = self.classifier(sequence_output)
1390
+
1391
+ loss = None
1392
+ if labels is not None:
1393
+ loss_fct = CrossEntropyLoss()
1394
+
1395
+ labels = labels.to(logits.device)
1396
+ loss = loss_fct(logits.view(-1, self.num_labels), labels.view(-1))
1397
+
1398
+ if not return_dict:
1399
+ output = (logits,) + outputs[2:]
1400
+ return ((loss,) + output) if loss is not None else output
1401
+
1402
+ return TokenClassifierOutput(
1403
+ loss=loss,
1404
+ logits=logits,
1405
+ hidden_states=outputs.hidden_states,
1406
+ attentions=outputs.attentions,
1407
+ )
1408
+
1409
+
1410
+ class EsmClassificationHead(nn.Module):
1411
+ """Head for sentence-level classification tasks."""
1412
+
1413
+ def __init__(self, config):
1414
+ super().__init__()
1415
+ self.dense = nn.Linear(config.hidden_size, config.hidden_size)
1416
+ self.dropout = nn.Dropout(config.hidden_dropout_prob)
1417
+ self.out_proj = nn.Linear(config.hidden_size, config.num_labels)
1418
+
1419
+ def forward(self, features, **kwargs):
1420
+ x = features[:, 0, :] # take <s> token (equiv. to [CLS])
1421
+ x = self.dropout(x)
1422
+ x = self.dense(x)
1423
+ x = torch.tanh(x)
1424
+ x = self.dropout(x)
1425
+ x = self.out_proj(x)
1426
+ return x
1427
+
1428
+
1429
+ def create_position_ids_from_input_ids(
1430
+ input_ids, padding_idx, past_key_values_length=0
1431
+ ):
1432
+ """
1433
+ Replace non-padding symbols with their position numbers. Position numbers begin at padding_idx+1. Padding symbols
1434
+ are ignored. This is modified from fairseq's `utils.make_positions`.
1435
+
1436
+ Args:
1437
+ x: torch.Tensor x:
1438
+
1439
+ Returns: torch.Tensor
1440
+ """
1441
+ # The series of casts and type-conversions here are carefully balanced to both work with ONNX export and XLA.
1442
+ mask = input_ids.ne(padding_idx).int()
1443
+ incremental_indices = (
1444
+ torch.cumsum(mask, dim=1).type_as(mask) + past_key_values_length
1445
+ ) * mask
1446
+ return incremental_indices.long() + padding_idx
special_tokens_map.json ADDED
@@ -0,0 +1,6 @@
 
 
 
 
 
 
 
1
+ {
2
+ "cls_token": "<cls>",
3
+ "mask_token": "<mask>",
4
+ "pad_token": "<pad>",
5
+ "unk_token": "<unk>"
6
+ }
tokenizer_config.json ADDED
@@ -0,0 +1,44 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ {
2
+ "added_tokens_decoder": {
3
+ "0": {
4
+ "content": "<unk>",
5
+ "lstrip": false,
6
+ "normalized": false,
7
+ "rstrip": false,
8
+ "single_word": false,
9
+ "special": true
10
+ },
11
+ "1": {
12
+ "content": "<pad>",
13
+ "lstrip": false,
14
+ "normalized": false,
15
+ "rstrip": false,
16
+ "single_word": false,
17
+ "special": true
18
+ },
19
+ "2": {
20
+ "content": "<mask>",
21
+ "lstrip": false,
22
+ "normalized": false,
23
+ "rstrip": false,
24
+ "single_word": false,
25
+ "special": true
26
+ },
27
+ "3": {
28
+ "content": "<cls>",
29
+ "lstrip": false,
30
+ "normalized": false,
31
+ "rstrip": false,
32
+ "single_word": false,
33
+ "special": true
34
+ }
35
+ },
36
+ "clean_up_tokenization_spaces": true,
37
+ "cls_token": "<cls>",
38
+ "eos_token": null,
39
+ "mask_token": "<mask>",
40
+ "model_max_length": 512,
41
+ "pad_token": "<pad>",
42
+ "tokenizer_class": "EsmTokenizer",
43
+ "unk_token": "<unk>"
44
+ }
vocab.txt ADDED
@@ -0,0 +1,8003 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ <unk>
2
+ <pad>
3
+ <mask>
4
+ <cls>
5
+ <eos>
6
+ <bos>
7
+ TT
8
+ AA
9
+ CC
10
+ GG
11
+ AT
12
+ AG
13
+ CT
14
+ AC
15
+ GT
16
+ ATT
17
+ GC
18
+ AAT
19
+ TTT
20
+ AGG
21
+ GAA
22
+ ACC
23
+ NN
24
+ CAA
25
+ CTT
26
+ GTT
27
+ ACT
28
+ AGT
29
+ GCC
30
+ GAT
31
+ CAT
32
+ GGT
33
+ AAAA
34
+ GCT
35
+ GAG
36
+ NNNN
37
+ ATTT
38
+ CCT
39
+ GAC
40
+ CGG
41
+ CAG
42
+ CAC
43
+ ATAT
44
+ AATT
45
+ AAAT
46
+ CGT
47
+ TTTT
48
+ NNNNNNNN
49
+ GAGG
50
+ GTTT
51
+ GATT
52
+ CATT
53
+ CTTT
54
+ ACAA
55
+ AGAA
56
+ GAAT
57
+ ACTT
58
+ ACAT
59
+ ACCT
60
+ CGC
61
+ CCTT
62
+ CAAT
63
+ AGTT
64
+ CCAA
65
+ GCTT
66
+ AGAT
67
+ ATTTT
68
+ CTCT
69
+ GGTT
70
+ AGGT
71
+ ATGT
72
+ GCAA
73
+ CACC
74
+ GACC
75
+ ATAA
76
+ GGAA
77
+ GAGT
78
+ AGCT
79
+ GTGT
80
+ GCCT
81
+ CCAT
82
+ GCAT
83
+ CGAA
84
+ GACT
85
+ CACT
86
+ GGAT
87
+ CTAA
88
+ CTCC
89
+ CAGG
90
+ GGCC
91
+ CGCC
92
+ AGCC
93
+ GGGT
94
+ GGCT
95
+ CAGT
96
+ AAGT
97
+ GTTTT
98
+ CGAT
99
+ CTTTT
100
+ AGAG
101
+ CTAT
102
+ GGGG
103
+ ACAC
104
+ AAAAT
105
+ CGGT
106
+ CGAG
107
+ GTAT
108
+ GTCC
109
+ CAAAA
110
+ GTAA
111
+ CGTT
112
+ CCCC
113
+ GATTT
114
+ CGAC
115
+ GAAAA
116
+ GTGG
117
+ CATTT
118
+ CCCT
119
+ ATCT
120
+ GAATT
121
+ CGCT
122
+ ATGG
123
+ CAATT
124
+ AAATT
125
+ GTCT
126
+ AAGG
127
+ GCGG
128
+ AACT
129
+ AATTT
130
+ CAAAT
131
+ ATTTTT
132
+ AGTTT
133
+ ACTTT
134
+ AATAT
135
+ GCAC
136
+ ATTAT
137
+ GCAG
138
+ AACC
139
+ GGAG
140
+ ACCTT
141
+ GAAAT
142
+ AAAG
143
+ GGAC
144
+ GAGTT
145
+ CACTT
146
+ GCTTT
147
+ ACAAT
148
+ AATTTT
149
+ CTGT
150
+ ACGT
151
+ GACTT
152
+ AAAATT
153
+ ACATT
154
+ ATCC
155
+ CGAGG
156
+ CTGG
157
+ GCGT
158
+ AGCAA
159
+ AGAGG
160
+ AATAA
161
+ AGCTT
162
+ GCCTT
163
+ ACGG
164
+ GCGC
165
+ AAGAA
166
+ CTCTT
167
+ AGATT
168
+ AGAAT
169
+ GCATT
170
+ CTCAA
171
+ CATAT
172
+ AAAAAT
173
+ AGGTT
174
+ CCTTT
175
+ GAGGT
176
+ GCACC
177
+ GGAGG
178
+ CTTGT
179
+ AGCAT
180
+ GGTTT
181
+ CCTCC
182
+ GCAAT
183
+ CACCT
184
+ GTTGT
185
+ ATTGT
186
+ AACAA
187
+ CACAT
188
+ AGAC
189
+ GATAT
190
+ CATTTT
191
+ AAAC
192
+ CTTCT
193
+ GATGT
194
+ ACCAT
195
+ GACCT
196
+ AATGT
197
+ CATGT
198
+ CTTTTT
199
+ GAAGG
200
+ CAGTT
201
+ GATTTT
202
+ ACCAA
203
+ CGACC
204
+ CTTCC
205
+ CAAGT
206
+ GTTTTT
207
+ GAGAT
208
+ GAGAA
209
+ GACAT
210
+ AGAAAA
211
+ ATTAA
212
+ GTTGG
213
+ GAAGT
214
+ CACAA
215
+ CTTGG
216
+ ATTCT
217
+ CCTCT
218
+ GCCAT
219
+ CCAC
220
+ GCAGG
221
+ TTTTTT
222
+ CCGG
223
+ GTTAT
224
+ CCGT
225
+ GGTGT
226
+ GGTGG
227
+ AGAGT
228
+ GATGG
229
+ CCCAA
230
+ ACTAT
231
+ CTTAT
232
+ CTCAT
233
+ GAAAAT
234
+ GACAA
235
+ AGGAA
236
+ ATTATT
237
+ GCGCC
238
+ GAGCT
239
+ CAAGG
240
+ GAAGAA
241
+ CGATT
242
+ GCACT
243
+ ATATATAT
244
+ ATTTAT
245
+ CATCT
246
+ AGTAT
247
+ AATCT
248
+ GCCAA
249
+ AGGAT
250
+ AATGG
251
+ AGACT
252
+ CAGGT
253
+ CATGG
254
+ ACACT
255
+ ACAAAA
256
+ GAACT
257
+ GAATTT
258
+ CATAA
259
+ GATCT
260
+ AGTGT
261
+ GATAA
262
+ CGAGT
263
+ CAGAT
264
+ ACACC
265
+ GGTAT
266
+ CGAAT
267
+ CTTCTT
268
+ CGTTT
269
+ ATTGG
270
+ GCTCC
271
+ AGTGG
272
+ CAGCT
273
+ AGCCT
274
+ GTTCT
275
+ ATATAT
276
+ AGTCC
277
+ AATAAT
278
+ CAACT
279
+ CAGAA
280
+ CATCC
281
+ CGGTT
282
+ CAACC
283
+ GCTCT
284
+ AGGGG
285
+ CAATTT
286
+ ACTAA
287
+ CGGCC
288
+ AAAAAA
289
+ GAGCC
290
+ GAACC
291
+ CAAAAT
292
+ AGACC
293
+ GCAGT
294
+ AGAAAT
295
+ CTTAA
296
+ GCTAT
297
+ CGCCT
298
+ AGTTTT
299
+ ATTCC
300
+ CAGCC
301
+ GATCC
302
+ CGCTT
303
+ GTTAA
304
+ CGACT
305
+ GCAAAA
306
+ AGTAA
307
+ CGGCT
308
+ GCTAA
309
+ AATCC
310
+ AGGGT
311
+ CCTAT
312
+ ACTCT
313
+ ACCCT
314
+ ACTCC
315
+ GCTGG
316
+ GGTCC
317
+ TTTAT
318
+ ACTTTT
319
+ GTTCC
320
+ AGCAG
321
+ GGTAA
322
+ CATCAA
323
+ GAAATT
324
+ GATGAT
325
+ AGGCT
326
+ GGTCT
327
+ GCTTTT
328
+ ACAGT
329
+ GTGTT
330
+ CCTAA
331
+ ACAAAT
332
+ GCCCC
333
+ ACGAA
334
+ AATTAT
335
+ GGCAA
336
+ ATTTTTT
337
+ ATTTGT
338
+ ACTGT
339
+ GCTGT
340
+ TTTGT
341
+ AGTCT
342
+ ACAG
343
+ AGGCC
344
+ ATTTCT
345
+ GGCGG
346
+ CATCAT
347
+ CCTGT
348
+ AGCAC
349
+ GGACT
350
+ GATGAA
351
+ AGCGG
352
+ GCCCT
353
+ ACATAT
354
+ AATATT
355
+ CAAATT
356
+ ACAGG
357
+ GGATT
358
+ ACCCC
359
+ AGAATT
360
+ GACGT
361
+ CGTCC
362
+ GCAAAT
363
+ GTTGTT
364
+ GACGG
365
+ TTTCT
366
+ CAACAA
367
+ ATTTAA
368
+ GTGAT
369
+ CACCTT
370
+ GGAAT
371
+ GCCGCC
372
+ GTGAA
373
+ GGGC
374
+ CAAGAA
375
+ AATTAA
376
+ AAATAA
377
+ AGAGAA
378
+ CGGAT
379
+ AAAATTT
380
+ ACACAA
381
+ GGCAT
382
+ GCGAA
383
+ CGTGT
384
+ GTTCTT
385
+ AATCAA
386
+ GCATGT
387
+ GGGAA
388
+ GGTGGT
389
+ GGCTT
390
+ ACTACT
391
+ ATTCAT
392
+ ACAATT
393
+ GAGTTT
394
+ ACATTT
395
+ GATCAA
396
+ CTCCT
397
+ AGATTT
398
+ GCCGT
399
+ CCCTT
400
+ GCATAT
401
+ GGGTT
402
+ GGAGT
403
+ ATTAAT
404
+ CGGAA
405
+ AATTTTT
406
+ GGACC
407
+ CATCTT
408
+ GCATTT
409
+ GGGCC
410
+ ATTCTT
411
+ GTCTT
412
+ ATTGAT
413
+ ATTCAA
414
+ AATGAA
415
+ GGGGT
416
+ AGTAGT
417
+ CCACC
418
+ ACGCC
419
+ AAAAAAAA
420
+ ATTGTT
421
+ CGTCT
422
+ ATTGAA
423
+ GCGCT
424
+ GCGAG
425
+ CGGGT
426
+ CGCAT
427
+ CCTCCT
428
+ ACACAT
429
+ AGCTTT
430
+ GGGCT
431
+ GCGGT
432
+ GCACAA
433
+ AGAGAT
434
+ TTTAA
435
+ GAAGCT
436
+ CTTCAA
437
+ GTCAT
438
+ GGCCT
439
+ GAGGTT
440
+ GTTGAT
441
+ AATCAT
442
+ CAATAT
443
+ AGATAT
444
+ GCTGCT
445
+ GGGAT
446
+ AATAAAA
447
+ AGGTTT
448
+ ACACTT
449
+ CCACT
450
+ CACGT
451
+ ACGAG
452
+ GTTGAA
453
+ GCGAT
454
+ CATTAT
455
+ AGAGTT
456
+ ACGAT
457
+ ACCTTT
458
+ CGCAA
459
+ GAATAT
460
+ AAAACT
461
+ CACTTT
462
+ GTCAA
463
+ GAAGAT
464
+ AGCCTT
465
+ CGGCGG
466
+ CTTCAT
467
+ GCAATT
468
+ AATGAT
469
+ GTTTAT
470
+ CGTAT
471
+ AATGTT
472
+ GCATAA
473
+ GCACTT
474
+ GCACAT
475
+ ACGGT
476
+ CCAAT
477
+ CCATT
478
+ CATGTT
479
+ CTGAA
480
+ AAATGT
481
+ CGTTTT
482
+ AGGAGG
483
+ CTTGAT
484
+ AGCAAT
485
+ ATATGT
486
+ GCGAC
487
+ CCTTTT
488
+ AGCCAA
489
+ AGACTT
490
+ GATTAT
491
+ GCTCAA
492
+ ATATAA
493
+ CTTTCT
494
+ CTTTAT
495
+ AATCTT
496
+ GACTTT
497
+ CACATT
498
+ GGGAG
499
+ GACCTT
500
+ GGAAAA
501
+ ACATGT
502
+ GTTCAT
503
+ ATTTTAT
504
+ CTTCCT
505
+ ACCACC
506
+ GTTTGT
507
+ GAAGGT
508
+ CACCAA
509
+ AGCATT
510
+ AAAAGT
511
+ GGTTTT
512
+ CTTTGT
513
+ CTTGTT
514
+ GCGTT
515
+ AGCGT
516
+ GTTTCT
517
+ CTTGGT
518
+ ACGAC
519
+ AGACAA
520
+ ACACCT
521
+ CACCAT
522
+ CTTGAA
523
+ CATGAT
524
+ AAAAAAT
525
+ CTTCGG
526
+ AAATCT
527
+ CATATT
528
+ CAGTTT
529
+ CCTGG
530
+ GAGCAA
531
+ CCTCAA
532
+ AGCCAT
533
+ CCTCGG
534
+ GCCACC
535
+ CATGAA
536
+ GAGGAT
537
+ GCCGG
538
+ ACTCAA
539
+ CTTTTTT
540
+ GCAGAA
541
+ GAGGAA
542
+ AGACAT
543
+ GTTCAA
544
+ CGATTT
545
+ GATTTTT
546
+ AGTGAA
547
+ ATGTAT
548
+ CGAGGT
549
+ AGTTAT
550
+ CAGCAA
551
+ GCCTTT
552
+ GTTTTTT
553
+ CTATT
554
+ GGTGAT
555
+ CGCGG
556
+ ACAAGT
557
+ CGTGG
558
+ AGAGGT
559
+ CCAAAA
560
+ GCTCGG
561
+ AGTTGT
562
+ GGTGAA
563
+ CCAGG
564
+ GAGCTT
565
+ CCCCT
566
+ ACCGT
567
+ CTCTCT
568
+ ACTTAT
569
+ GAGAGG
570
+ AGAAGT
571
+ AGTGAT
572
+ AACAT
573
+ CGAGTT
574
+ CCCAT
575
+ AAAAATT
576
+ AGAGCT
577
+ GAACAA
578
+ CAGGTT
579
+ CGTCGT
580
+ CATTTTT
581
+ GATGTT
582
+ AATTGT
583
+ AGTCAA
584
+ ACCCAA
585
+ AATTCT
586
+ ATTTTTTT
587
+ ACGTT
588
+ GACCAA
589
+ GAATAA
590
+ ACAGAA
591
+ CGCACC
592
+ CATTGT
593
+ CGCGT
594
+ GAAAGG
595
+ GCAGAT
596
+ CCTCTT
597
+ AGCTCT
598
+ ACTTGT
599
+ GAATGT
600
+ CACGG
601
+ CTAGG
602
+ ACTGG
603
+ ATTTGG
604
+ CCAAGT
605
+ GAGCAT
606
+ GCGAGG
607
+ ACGCT
608
+ CTGCT
609
+ CTGAT
610
+ CGACTT
611
+ CGCCTT
612
+ ATTTCC
613
+ AAGTT
614
+ CCTTGT
615
+ GAGATT
616
+ CTGTT
617
+ CTAAT
618
+ CGGGG
619
+ GCTCTT
620
+ CATTAA
621
+ CTACT
622
+ GCAGCT
623
+ GCAGCC
624
+ CACACC
625
+ GTCCGGT
626
+ CAGCAG
627
+ GCACCT
628
+ CGAATT
629
+ CAATAA
630
+ CTTTAA
631
+ ACATAA
632
+ CACAAT
633
+ GAATTTT
634
+ CGTAA
635
+ CATAAT
636
+ AGATGT
637
+ CTCGG
638
+ GGTGTT
639
+ GGTTAT
640
+ GGTCAA
641
+ AGCACT
642
+ GCAGGT
643
+ GAGAAT
644
+ CAATGT
645
+ GGTTGT
646
+ CGACCT
647
+ GCTTGT
648
+ GATCAT
649
+ AGCACC
650
+ GACATT
651
+ GCTTAT
652
+ ACTATT
653
+ CTTGCT
654
+ AGGCAA
655
+ GACCAT
656
+ GCCCAA
657
+ CTCCCC
658
+ GATAAT
659
+ AAAACC
660
+ GATATT
661
+ CCTCAT
662
+ ATTTATT
663
+ AGTCTT
664
+ GACGAA
665
+ GTTATT
666
+ CCTTAT
667
+ CAGAAT
668
+ AAAATTTT
669
+ ATGTGT
670
+ GCAGTT
671
+ AGTAAT
672
+ GTTTAA
673
+ GATTAA
674
+ ACTCTT
675
+ GACAAT
676
+ GAGTAT
677
+ AGCAGG
678
+ ACTGTT
679
+ GAATCT
680
+ GACACC
681
+ GCCGAA
682
+ ACTAAT
683
+ AGGAAT
684
+ AGCGC
685
+ GGCAG
686
+ GCTTCT
687
+ AGTGTT
688
+ GCCATT
689
+ AGAAAAT
690
+ ATAATTT
691
+ CCTTTTT
692
+ GTGTGT
693
+ AAAAGAA
694
+ CCGAA
695
+ GATTGT
696
+ AGTATT
697
+ AGATAA
698
+ GATTCT
699
+ GCTCCT
700
+ ACTCAT
701
+ AGGGTT
702
+ GCCCTT
703
+ CAACAT
704
+ GCTCAT
705
+ AGCAGT
706
+ CTCTAT
707
+ AGATTTT
708
+ GAACTT
709
+ CAGAGG
710
+ GGAGAA
711
+ ACTCGG
712
+ GGCGT
713
+ AGTGGT
714
+ CAGCTT
715
+ ACTTAA
716
+ AGGTGT
717
+ AGTCAT
718
+ AAAATAT
719
+ ACCAAT
720
+ GCCTCC
721
+ ACCATT
722
+ CTTATT
723
+ AGTTTTT
724
+ ACTGAA
725
+ ACATTTT
726
+ GGAAAT
727
+ ATATCT
728
+ ATTTGAT
729
+ GAGTTTT
730
+ ATTTAAT
731
+ AAAAAAAT
732
+ GGAAGT
733
+ AAGTAT
734
+ ACAGAT
735
+ CAGATT
736
+ CCTTCC
737
+ CGGAGG
738
+ GCTGAA
739
+ CATTCT
740
+ GGTCTT
741
+ CTTTCC
742
+ ACTTCT
743
+ CCAACC
744
+ CACTAT
745
+ GCCCCT
746
+ CAATTTT
747
+ AGGATT
748
+ ATTTCTT
749
+ GCGGCC
750
+ AGGCTT
751
+ AGGGAA
752
+ CTCGT
753
+ CGCGCC
754
+ GGTAAT
755
+ CACTAA
756
+ AGGTAT
757
+ AGCTAT
758
+ AAAAGG
759
+ GCAAGT
760
+ GATCTT
761
+ AGGAGT
762
+ AAATAAT
763
+ AGAAGAA
764
+ ACAATTT
765
+ GGCTAT
766
+ AGTTAA
767
+ ACAACT
768
+ ACCTAT
769
+ CGCCGT
770
+ ACAAAAT
771
+ ACATCT
772
+ GCATTTT
773
+ CTAAGT
774
+ GTTGCT
775
+ CTTTGG
776
+ CCTTCT
777
+ ACCCCT
778
+ ATAAAAT
779
+ AATTAAT
780
+ GTGTAT
781
+ AAAACAA
782
+ AATTTTTT
783
+ CCGAG
784
+ GTTTGG
785
+ CGCCAT
786
+ ATAAGT
787
+ GTTGGT
788
+ ATTTCAA
789
+ GAACAT
790
+ GAGGGT
791
+ AAATATT
792
+ CAATCT
793
+ ACTCCT
794
+ GTTAAT
795
+ ACTGAT
796
+ ACCTAA
797
+ GACTAT
798
+ CAGCAT
799
+ GACGAC
800
+ CAATCC
801
+ CGGTTT
802
+ ACTTTTT
803
+ CAAAGG
804
+ GCGCGG
805
+ GCATCT
806
+ CGAGAT
807
+ GGTGCT
808
+ GGCAC
809
+ ACCCTT
810
+ GGTCAT
811
+ GAGAAAA
812
+ CCATCT
813
+ ACCACT
814
+ AATTCC
815
+ CGAAGT
816
+ CGTCGG
817
+ CCTTAA
818
+ GAGGCT
819
+ ATTTCAT
820
+ GGTATT
821
+ ATATATT
822
+ AAATCC
823
+ ACAGTT
824
+ CTCTCC
825
+ ACCCAT
826
+ GAAGTT
827
+ GCAACT
828
+ CAAACT
829
+ GTTTCC
830
+ CAAAGT
831
+ GCCACT
832
+ GCGCTT
833
+ CTCTAA
834
+ GGTTAA
835
+ TTTTAT
836
+ GAAAAAT
837
+ ATTTTGT
838
+ ACGAGG
839
+ AGACCT
840
+ AGCTAA
841
+ GATGGT
842
+ AGATCT
843
+ AATTATT
844
+ AGAACT
845
+ CAAGTT
846
+ CAACTT
847
+ GCCAAT
848
+ GCCCAT
849
+ ATTTTAA
850
+ CAAAAAT
851
+ GATGCT
852
+ GACTAA
853
+ AGGAAAA
854
+ ATGTAA
855
+ ACCGG
856
+ AGAATTT
857
+ AGTGCT
858
+ AGGGGT
859
+ CGACAA
860
+ GAGACT
861
+ CACAC
862
+ CGAAAA
863
+ ATTTGTT
864
+ CCTCGT
865
+ CAAGAT
866
+ GCGCCT
867
+ CGAGCC
868
+ ACCTTTT
869
+ ACAACC
870
+ CGAAAT
871
+ ATTTGAA
872
+ AGAGCC
873
+ CACACT
874
+ CAGGAT
875
+ GCTTCC
876
+ GGATCT
877
+ GAGTGT
878
+ GCGTGT
879
+ GGTTTTT
880
+ AGCATTT
881
+ GACAC
882
+ GATTCC
883
+ GCTATT
884
+ GCGCAA
885
+ GGGTAT
886
+ AGTTCT
887
+ CATCCT
888
+ GATCCT
889
+ CAGCCT
890
+ GAGTCT
891
+ CTTAAT
892
+ GTTTTAT
893
+ CTTTTAT
894
+ CACAAAA
895
+ GAAACT
896
+ AGAAATT
897
+ GGACAGTCC
898
+ AGGCAT
899
+ CATTCC
900
+ AGAAGG
901
+ AGCAAAA
902
+ GAAAGT
903
+ GCCAC
904
+ GAGGCC
905
+ GCCTCT
906
+ CCAACT
907
+ CGCTTT
908
+ GAGAGT
909
+ CGTTGT
910
+ CTCTGT
911
+ CGGCAA
912
+ GAAAAAA
913
+ AGGGTTT
914
+ ATAAATT
915
+ CGACAT
916
+ ACCTCC
917
+ GGTTCT
918
+ ACATCC
919
+ GACTCC
920
+ GTTCCT
921
+ GCCTAT
922
+ CCAAGG
923
+ GAATTAT
924
+ GAATCC
925
+ CATGCT
926
+ CACTTTT
927
+ GCAACC
928
+ GAGCCT
929
+ GGTTGG
930
+ CCAAAAT
931
+ ACCTCT
932
+ AGTACT
933
+ GCATCC
934
+ ATATAAT
935
+ CAGGAA
936
+ AAAACAT
937
+ GCTTAA
938
+ GGAAGG
939
+ ATTTATTT
940
+ CAGTAT
941
+ ACAAATT
942
+ CACTGT
943
+ GGATGG
944
+ AGCTGT
945
+ AAAATAA
946
+ GCTGAT
947
+ AAATGG
948
+ GCTAAT
949
+ AAATCAA
950
+ CTCCCT
951
+ GCTGCC
952
+ CAATGG
953
+ ACTTGG
954
+ CGAGAA
955
+ GGCTGT
956
+ ACAGGT
957
+ AGATGG
958
+ GCAATTT
959
+ AGCTCC
960
+ ATATCC
961
+ CACCCT
962
+ CCATCC
963
+ GCTTTTT
964
+ AGATCC
965
+ CTTCGT
966
+ ACCAAAA
967
+ ATAACT
968
+ AGCTTTT
969
+ CTAATTT
970
+ ACATGG
971
+ GGTGCC
972
+ GCACAC
973
+ CAATAAT
974
+ GTTAGT
975
+ AGGGAT
976
+ CTTTCTT
977
+ ATTTTCT
978
+ GGTCGG
979
+ ACTAGT
980
+ GCTTGG
981
+ CTCTCTCT
982
+ AGCGCC
983
+ CGATAT
984
+ GACGCC
985
+ ACAAGG
986
+ GGATCC
987
+ GACTTTT
988
+ GCTCGT
989
+ AGGTGG
990
+ GAGAC
991
+ CGAAGG
992
+ GACACT
993
+ AATTCAT
994
+ GCAGAG
995
+ ATGTCT
996
+ CCTTGG
997
+ AGACAC
998
+ GTATT
999
+ AATTCAA
1000
+ CGAGCT
1001
+ CATTCAT
1002
+ GCGGGG
1003
+ GACAGG
1004
+ CACGAA
1005
+ CAGTTTT
1006
+ GAGTAA
1007
+ AAATTAT
1008
+ AAGTAA
1009
+ CCTATT
1010
+ CGGGCC
1011
+ AGGTAA
1012
+ GTAAT
1013
+ GGAACT
1014
+ CTAAAAT
1015
+ ACCAC
1016
+ GCCTAA
1017
+ ACCATTT
1018
+ ATTAGT
1019
+ ACTGCT
1020
+ GGGTAA
1021
+ ATTGCT
1022
+ AAATCAT
1023
+ AGGTTTT
1024
+ AAAACTT
1025
+ CACCCC
1026
+ CCTAAT
1027
+ CGGTGT
1028
+ GCGACC
1029
+ GAGCAG
1030
+ GGTTCC
1031
+ GTTGCC
1032
+ ATTATTT
1033
+ GTTTGAT
1034
+ GAGCGG
1035
+ CAAGGT
1036
+ CGTCAT
1037
+ ATTAAAA
1038
+ GGAAAAT
1039
+ CTATCT
1040
+ GAAGCC
1041
+ GACAAAA
1042
+ ACTTCC
1043
+ GCGGCT
1044
+ CCAATTT
1045
+ CGATGT
1046
+ CCATGG
1047
+ ACAGCT
1048
+ CACTCT
1049
+ AATTTAT
1050
+ CGCCGG
1051
+ GAGGAGG
1052
+ AAATAAAT
1053
+ CCTGAA
1054
+ CTCCACC
1055
+ GAGCAC
1056
+ ATTAATT
1057
+ ATTTTTAT
1058
+ GCGTGG
1059
+ AGCAATT
1060
+ GCAAGG
1061
+ GATACC
1062
+ ATATGG
1063
+ CGCCAA
1064
+ GTGTCT
1065
+ GCTGGT
1066
+ CAGAGT
1067
+ GACCCC
1068
+ AGCCCC
1069
+ AGGCCT
1070
+ CAAAATT
1071
+ CAAATTT
1072
+ CATTGG
1073
+ GTGTAA
1074
+ AGCGAA
1075
+ ATGTCC
1076
+ GCAAAAT
1077
+ CAGGGT
1078
+ CGTCTT
1079
+ AGAACC
1080
+ GCGGAA
1081
+ ATTCCT
1082
+ GACTCT
1083
+ CAGTGT
1084
+ GACAGT
1085
+ GAATGG
1086
+ GCATGG
1087
+ AAGTCT
1088
+ GGGTCC
1089
+ GCTAGT
1090
+ ACAAGAA
1091
+ GAGTCC
1092
+ ACGGAA
1093
+ CAAACC
1094
+ CACCGT
1095
+ ATTAAAT
1096
+ GTTTTGT
1097
+ TTTCC
1098
+ CTAACT
1099
+ GTTTGTT
1100
+ GGCCGT
1101
+ CGTCCT
1102
+ CTTTTGT
1103
+ CACAGG
1104
+ GAGAAAT
1105
+ CGTCAA
1106
+ GATTTAT
1107
+ CGATCT
1108
+ CACGCC
1109
+ CATGGT
1110
+ GGAACC
1111
+ GAACCT
1112
+ TTTTTTT
1113
+ CAGAAAA
1114
+ GAAATTT
1115
+ ACCTGT
1116
+ CAGACT
1117
+ GAAAATT
1118
+ GAAACC
1119
+ GCTGTT
1120
+ AGTTCC
1121
+ ACAACAA
1122
+ ATTACT
1123
+ AAGTCC
1124
+ AATATTT
1125
+ GGGTCT
1126
+ CATGCC
1127
+ AGTCCT
1128
+ AGAGAGAG
1129
+ AATAATT
1130
+ GTTGAG
1131
+ TTTGG
1132
+ CAGACC
1133
+ GTTGTGT
1134
+ CAATTAT
1135
+ GATTGG
1136
+ GACGAT
1137
+ AGTAAAA
1138
+ CATTTAT
1139
+ CACAAAT
1140
+ CTTGAG
1141
+ CGCCGCC
1142
+ CCTAGG
1143
+ ACTAAAA
1144
+ GACTGT
1145
+ CCTTCTT
1146
+ GAAGAG
1147
+ AATAAAT
1148
+ AATATAT
1149
+ ACTCGT
1150
+ GCGGAT
1151
+ AGTTGG
1152
+ GCTAC
1153
+ CAGAC
1154
+ AATCCT
1155
+ AATTGG
1156
+ CGGTCC
1157
+ GCTTCGG
1158
+ ATTGGT
1159
+ GATCAAT
1160
+ GTTTCTT
1161
+ CGATCC
1162
+ ATGTGG
1163
+ CACTCC
1164
+ GCTACT
1165
+ CAGGCC
1166
+ CGACGT
1167
+ CAGTAA
1168
+ GAAAC
1169
+ GCGAAT
1170
+ GATAGT
1171
+ CTTTTCT
1172
+ AATTAATT
1173
+ AAATAAAA
1174
+ GGACAGTCCGGT
1175
+ GACCCT
1176
+ AGTTTAT
1177
+ GCGGGT
1178
+ CTCCTTT
1179
+ GATGCC
1180
+ CTTTGTT
1181
+ CGGCTT
1182
+ AGCCGT
1183
+ GATGAAT
1184
+ AGAGTTT
1185
+ CAGGCT
1186
+ CACAGT
1187
+ CAATCAA
1188
+ CATCGG
1189
+ CACAAGT
1190
+ GGAATTT
1191
+ CGCCCC
1192
+ CCAAATT
1193
+ GTATCT
1194
+ ACGAAT
1195
+ GGTAGT
1196
+ GCGCGT
1197
+ GCACGT
1198
+ GCTACC
1199
+ AGCGAT
1200
+ AATAGT
1201
+ ATATGTTT
1202
+ GGCCCT
1203
+ CGTGTT
1204
+ AGGACT
1205
+ CAGCGG
1206
+ GCCTGT
1207
+ CTTGCC
1208
+ AAATGAT
1209
+ ACGTGT
1210
+ AATGGT
1211
+ GCGTCC
1212
+ ATAACC
1213
+ GCGAGT
1214
+ GAGACC
1215
+ ATATGAT
1216
+ CGATTTT
1217
+ GTCCGGTGT
1218
+ ATATGTT
1219
+ CCTGCT
1220
+ ACTTGTT
1221
+ CGTGCC
1222
+ CTAACC
1223
+ CGGTGG
1224
+ CAAAATTT
1225
+ CGCTCC
1226
+ CGAACC
1227
+ ATATCAT
1228
+ GAGGGG
1229
+ GGAAGAA
1230
+ GCACTTT
1231
+ AGAAGAT
1232
+ CGCAGG
1233
+ GGTCCT
1234
+ CGGGTT
1235
+ AATTCTT
1236
+ ACCAGT
1237
+ CAAAAAA
1238
+ GTGTGG
1239
+ CGGCCT
1240
+ GCGGTT
1241
+ CGACGG
1242
+ AATACT
1243
+ AAAATTAT
1244
+ AATTGAA
1245
+ ACACGT
1246
+ CTCCGT
1247
+ CGGACC
1248
+ ATTTGCT
1249
+ GAATCAA
1250
+ AAATGAA
1251
+ GTAATTT
1252
+ GCGCAT
1253
+ GTGTCC
1254
+ GCAACAA
1255
+ GACATGT
1256
+ CTTTGAT
1257
+ GATTGAT
1258
+ CTTTCAA
1259
+ GTTTTCT
1260
+ CGGATT
1261
+ CTTTCAT
1262
+ ACACTTT
1263
+ GGCCGG
1264
+ CGATGG
1265
+ CGGCGT
1266
+ ACATCAT
1267
+ GACGGT
1268
+ AATTGAT
1269
+ ACAACTT
1270
+ ACTGGT
1271
+ ATATGAA
1272
+ CAGTCC
1273
+ AGCGTT
1274
+ ATTTAAAA
1275
+ CTTTTTTT
1276
+ ACATCAA
1277
+ AGTGCC
1278
+ CATTCTT
1279
+ GGGTGG
1280
+ ACAACAT
1281
+ ATTTTATT
1282
+ GCGATT
1283
+ GCTTCTT
1284
+ GCTAGG
1285
+ ACTTCAA
1286
+ CCAAGAA
1287
+ CAGTCT
1288
+ CTCCGG
1289
+ ACATGTT
1290
+ AGCAAAT
1291
+ GCCAGG
1292
+ GGTCGT
1293
+ CATTTTTT
1294
+ ACCGAA
1295
+ AACTT
1296
+ AGGTCT
1297
+ CTTTGAA
1298
+ CACATAT
1299
+ CCTGAT
1300
+ GAAAATTT
1301
+ AGCCCT
1302
+ CCTGTT
1303
+ CGAAAAT
1304
+ CATCAAT
1305
+ CACATTT
1306
+ AGGGAG
1307
+ GCTCAG
1308
+ GTTTGAA
1309
+ GGCCCC
1310
+ CCCCCT
1311
+ CTAAATT
1312
+ GCATCAA
1313
+ CACATGT
1314
+ AGGTGTT
1315
+ ACTAGG
1316
+ AAATTAA
1317
+ AATTGTT
1318
+ CTAAGG
1319
+ GTTTTAA
1320
+ AGATGAA
1321
+ GTTTTTTT
1322
+ AGAATAT
1323
+ CCCTGT
1324
+ ACTACTACTACT
1325
+ CGCCCT
1326
+ GGCTGG
1327
+ CATCAG
1328
+ GATGAC
1329
+ ACGGAT
1330
+ GCCAAAA
1331
+ ACTTTAT
1332
+ CACCGG
1333
+ ATTTGGT
1334
+ GGAAATT
1335
+ CTTCAG
1336
+ GCCTTTT
1337
+ ACTACC
1338
+ CGTGAA
1339
+ CAAAACC
1340
+ ACGTGG
1341
+ CATTATT
1342
+ GGACAGT
1343
+ CGCATT
1344
+ GTTTCAT
1345
+ GTCCCC
1346
+ AAATGTT
1347
+ CCTTCAT
1348
+ AGGTCC
1349
+ ATTTTGG
1350
+ CTTTATT
1351
+ ACATATT
1352
+ GATTTTTT
1353
+ CGGTAT
1354
+ GTTTCAA
1355
+ CGTGAT
1356
+ CGGGGT
1357
+ AATGCT
1358
+ GACCGT
1359
+ CGAACT
1360
+ AATTTTAT
1361
+ CCAAACC
1362
+ GAGTGG
1363
+ ATATCAA
1364
+ AGAGAGG
1365
+ GTCCCT
1366
+ AAAATGT
1367
+ ACATGAA
1368
+ GATAAAA
1369
+ CTTTTAA
1370
+ AATTAAAA
1371
+ CCTACT
1372
+ GGTACT
1373
+ ATAAGG
1374
+ CGGAC
1375
+ GAGAGAA
1376
+ GATTCAA
1377
+ GCCCGT
1378
+ GGTACC
1379
+ AGGACC
1380
+ CTTCCTT
1381
+ CTTGCTT
1382
+ GAATCAT
1383
+ GTAACT
1384
+ CGTTTTT
1385
+ GGTGGTT
1386
+ CTTCTTT
1387
+ CGCTGT
1388
+ CTTAAAA
1389
+ GGGTCGG
1390
+ CAAGCT
1391
+ CAGTGG
1392
+ ATTTAATT
1393
+ CAATATT
1394
+ GCGACT
1395
+ CTTAGG
1396
+ CAAAACT
1397
+ CAATTAA
1398
+ GATGAG
1399
+ AATACC
1400
+ GTATCC
1401
+ CGCAC
1402
+ CATAAAA
1403
+ CCTGGT
1404
+ GAATATT
1405
+ GTTAAAA
1406
+ CACACAA
1407
+ CGGAGT
1408
+ ACCCTAA
1409
+ CACCTTT
1410
+ GTTGTTT
1411
+ GCGTTT
1412
+ AGATCAA
1413
+ GGTGGAG
1414
+ CGTTAT
1415
+ GCACCTT
1416
+ ATTTAGT
1417
+ GATACT
1418
+ CCAACAA
1419
+ GCACACC
1420
+ ATTTTCC
1421
+ CACACAT
1422
+ AGCTGG
1423
+ AGGGCC
1424
+ AGAACAA
1425
+ ACGCAA
1426
+ CAATCAT
1427
+ GCTTGAT
1428
+ CGGGCT
1429
+ CTTACT
1430
+ AGCCTTT
1431
+ CCTCTCC
1432
+ AGACTTT
1433
+ GGATGAA
1434
+ ACCAAAT
1435
+ GCCAGT
1436
+ CAGCAC
1437
+ CATTTAA
1438
+ ACGAGT
1439
+ CCTCTCT
1440
+ CATTCAA
1441
+ GAATGAA
1442
+ GTCTGT
1443
+ CTATCC
1444
+ AGCGGT
1445
+ GATTATT
1446
+ CTTAGT
1447
+ AGCATAT
1448
+ GCCGCT
1449
+ GGACACT
1450
+ CGTGGT
1451
+ CATACT
1452
+ CATAGT
1453
+ ACGTTT
1454
+ ACGCTT
1455
+ GATTTGT
1456
+ GCAAATT
1457
+ AAAAACT
1458
+ GATAAAT
1459
+ AGCACTT
1460
+ ACAGCC
1461
+ TTTTGT
1462
+ ATGGTTT
1463
+ GTTACT
1464
+ AGCGCT
1465
+ CGATAA
1466
+ GTTACC
1467
+ AGATTAT
1468
+ CTATGG
1469
+ CGTGCT
1470
+ AGAATAA
1471
+ ATCTGT
1472
+ AATTTTTTT
1473
+ GCGCAC
1474
+ AGAAAAAT
1475
+ CGGAAT
1476
+ AGGGCT
1477
+ AACTGT
1478
+ GCAAGAA
1479
+ CATACC
1480
+ TTTTAA
1481
+ AGACAAT
1482
+ ACAGAG
1483
+ AAAAATAT
1484
+ ATTATAT
1485
+ GACATTT
1486
+ CCTAGT
1487
+ CGTTGG
1488
+ CAATCTT
1489
+ ACGATT
1490
+ AGCGAC
1491
+ ACGGTT
1492
+ AGTTCAA
1493
+ AGAGGAA
1494
+ AAATTGT
1495
+ GAATAAT
1496
+ GATTTCT
1497
+ GGAACAA
1498
+ GACGAG
1499
+ CGGTCT
1500
+ CTCTGG
1501
+ AAAAATAA
1502
+ CATTTGT
1503
+ CTTCAC
1504
+ AGTAGG
1505
+ CCTGCC
1506
+ GACAAAT
1507
+ CCTTGTT
1508
+ CCATCAA
1509
+ AGTACC
1510
+ CGGCGC
1511
+ GGTGAG
1512
+ ACTTGAA
1513
+ GCATCAT
1514
+ CATTAAT
1515
+ GTTTATT
1516
+ CAGGGG
1517
+ AGTGAG
1518
+ CCTAAGG
1519
+ TTTTTTTTT
1520
+ GAATTTTT
1521
+ AAAAAAAAT
1522
+ CTTTAAT
1523
+ ATTTTTGT
1524
+ ACAATAT
1525
+ CAGAAAT
1526
+ AAAAAGG
1527
+ GAAAACT
1528
+ CCTCCTT
1529
+ GTTCGT
1530
+ AGATGAT
1531
+ GATTCTT
1532
+ AGAGCAA
1533
+ ATATCTT
1534
+ ACAAGAT
1535
+ GAATGAT
1536
+ CCAAAGT
1537
+ CACGAT
1538
+ GGTCGAT
1539
+ ACTTCTT
1540
+ ACATAAT
1541
+ TTTTCT
1542
+ AGTTGAA
1543
+ CATGGCT
1544
+ CATTTCT
1545
+ CACAACT
1546
+ CCCCCC
1547
+ ACTCAG
1548
+ CGCGCT
1549
+ CGCTCT
1550
+ ATTTTCAT
1551
+ GTAACC
1552
+ GGAGAGG
1553
+ GAATTAA
1554
+ ATTTTAAT
1555
+ ACAAAATT
1556
+ ACAAAGT
1557
+ ACGACC
1558
+ GTTTGGT
1559
+ ATTTTTAA
1560
+ AGTTCTT
1561
+ AGACATT
1562
+ ACCTCAA
1563
+ ACGGCC
1564
+ AGCTCAA
1565
+ GCTTCAA
1566
+ GTTTTCC
1567
+ ACTTGAT
1568
+ CTTTTCC
1569
+ GAGCATT
1570
+ AAATTTTT
1571
+ CCTTGAT
1572
+ ACAAAGG
1573
+ AGTAGTAGTAGT
1574
+ GCTTTAT
1575
+ GAAATGGT
1576
+ GAGGCAA
1577
+ CATATTT
1578
+ GGATGAT
1579
+ AAAAGAT
1580
+ AATTTAA
1581
+ GGTTGAT
1582
+ GCGCAG
1583
+ GGTGAC
1584
+ CACGTT
1585
+ ACGCCT
1586
+ AGAAAATT
1587
+ AAAAGTT
1588
+ AGATATT
1589
+ GATTAAT
1590
+ CACACTT
1591
+ CCATCTT
1592
+ AAAAAATT
1593
+ ACCGCC
1594
+ ACCAGG
1595
+ CGGCAT
1596
+ AGTTCAT
1597
+ CCTTGCT
1598
+ GATTGAA
1599
+ CGGTAA
1600
+ AGTTGAT
1601
+ AGCGAG
1602
+ GGGGGG
1603
+ CAAATAT
1604
+ AAAAAGT
1605
+ CGGGAA
1606
+ AATTAGT
1607
+ GCAATAT
1608
+ GTTTAAT
1609
+ AGATAAT
1610
+ AGAAACT
1611
+ CCAAGTT
1612
+ CTTTGCC
1613
+ ACACATT
1614
+ CTTTGGT
1615
+ ATTTTGTT
1616
+ GCTTCAT
1617
+ ACACCAT
1618
+ CAATTTTT
1619
+ AGAGGTT
1620
+ ATAACAA
1621
+ ATGTGAT
1622
+ CTTACC
1623
+ ACTGCC
1624
+ AGAAAGT
1625
+ CCTTCAA
1626
+ ACTTCAT
1627
+ CAATGAA
1628
+ GAGGTTT
1629
+ GAGCCAA
1630
+ ACAAGTT
1631
+ GGTTCAA
1632
+ GTGGGGT
1633
+ ACATGAT
1634
+ GCATGAA
1635
+ CACAATT
1636
+ ATAACAT
1637
+ TTTTTTTT
1638
+ CTTTGCT
1639
+ ATTTACT
1640
+ AGTTTGT
1641
+ CAATGAT
1642
+ GCGTCT
1643
+ CACTGG
1644
+ GAATCTT
1645
+ CATTGAT
1646
+ AAATCTT
1647
+ AGCACCT
1648
+ ATTAGG
1649
+ AATGCC
1650
+ GCATGTT
1651
+ GATTCAT
1652
+ GAGAATT
1653
+ CATTGTT
1654
+ GAGAAGAA
1655
+ ATTTCCT
1656
+ CAATTCT
1657
+ ACGACT
1658
+ GAAAACC
1659
+ AGAAAGG
1660
+ CGACCTT
1661
+ ACATTAT
1662
+ ACCTTAT
1663
+ ACCTGG
1664
+ GGTAGG
1665
+ GACAAGG
1666
+ CAAATCC
1667
+ AGTTAAT
1668
+ ATTGTTT
1669
+ GAGTTTTT
1670
+ GAATTGT
1671
+ CAGATTT
1672
+ CACGCT
1673
+ GAGCGC
1674
+ CACATAA
1675
+ AGGTGAT
1676
+ GCCATTT
1677
+ CCATCAT
1678
+ ATGTCAT
1679
+ ACGTAT
1680
+ AGAACAT
1681
+ GCCTCGG
1682
+ GAATGTGAT
1683
+ GACTTGT
1684
+ GAGTTAT
1685
+ CGCTAT
1686
+ GACATGG
1687
+ GCATGAT
1688
+ CCTCAG
1689
+ GACACAA
1690
+ CCTTCGG
1691
+ ATTACC
1692
+ CTTCTCC
1693
+ GGTAAAA
1694
+ ACCTTGT
1695
+ ATTTATAT
1696
+ GCGTAT
1697
+ ACTAATT
1698
+ GGACTGTCCGGT
1699
+ AGTTGTT
1700
+ CAAGCC
1701
+ ACAGTTT
1702
+ ACAATAA
1703
+ GATTTAA
1704
+ ACGGGT
1705
+ CGCAAT
1706
+ AGACGG
1707
+ CCTCTTT
1708
+ CAGCCAA
1709
+ CGTTCC
1710
+ GTTCGG
1711
+ AGCACAT
1712
+ ATTTTTCT
1713
+ GGAGGAT
1714
+ ACATGCC
1715
+ AATTTGT
1716
+ GACGAGG
1717
+ CCTCCCC
1718
+ AGAAGTT
1719
+ CATCGT
1720
+ ACCAAGT
1721
+ GGACAT
1722
+ ACTTATT
1723
+ CTAACAA
1724
+ GGAAGAT
1725
+ ATAAGAA
1726
+ AGTAATT
1727
+ GCCTGG
1728
+ GAGCTTT
1729
+ AGAGAAT
1730
+ ACTTTGT
1731
+ AGTTATT
1732
+ CCTTCGT
1733
+ ACTAAAT
1734
+ GCAGTTT
1735
+ AGGAAAT
1736
+ GAGAAGG
1737
+ GAAAATGGT
1738
+ AGCAGTT
1739
+ AGGCGT
1740
+ GAGATTT
1741
+ GAGAAAG
1742
+ GACCGTT
1743
+ CAGCGT
1744
+ GCTTGTT
1745
+ GTTTTGG
1746
+ CCTTGAA
1747
+ CTCTCTT
1748
+ CATATAT
1749
+ CGAGGTT
1750
+ GAGAAGT
1751
+ AAAATCT
1752
+ ACCCGT
1753
+ ACAAACT
1754
+ GAGCGT
1755
+ GAATTCT
1756
+ ACACCTT
1757
+ CTTTCTTT
1758
+ AGTGTTT
1759
+ AATTAAAT
1760
+ AGTCGT
1761
+ CGCGAA
1762
+ CGACTTT
1763
+ GTAAGG
1764
+ AAAAATTT
1765
+ ACTTAAT
1766
+ CCCCGT
1767
+ GCTCAC
1768
+ GATATAT
1769
+ GACAAGT
1770
+ GTATGG
1771
+ GGACGT
1772
+ AGCTTGT
1773
+ ATGTAAT
1774
+ CGAATTT
1775
+ GTTAGG
1776
+ CCAAACT
1777
+ ATTCTTT
1778
+ ACCACAT
1779
+ CGTTCT
1780
+ ATGTCAA
1781
+ AGGAGAA
1782
+ CCCCTTT
1783
+ GGAACAT
1784
+ GCTAAAA
1785
+ CAACCT
1786
+ GGTTGAA
1787
+ CCGAGCCCT
1788
+ GCCTCGCC
1789
+ ATTGCC
1790
+ CGGACT
1791
+ GGTTGTT
1792
+ GCATTAT
1793
+ GTCCGT
1794
+ GACATAT
1795
+ ACTTGGT
1796
+ AAATACC
1797
+ GAGGAAT
1798
+ AGTATTT
1799
+ AGACGT
1800
+ ATTGAAT
1801
+ GGATCAA
1802
+ GACTCAA
1803
+ GGAGGAA
1804
+ GACGCT
1805
+ CCTCCAA
1806
+ GCAAGAT
1807
+ AGTAAAT
1808
+ CCTTAAT
1809
+ GATTTGG
1810
+ CAGAATT
1811
+ ACTTTAA
1812
+ CGGTTTT
1813
+ GATTGTT
1814
+ GAGATAT
1815
+ ATTTTGGT
1816
+ ATTTGTTT
1817
+ GCGGCGG
1818
+ ATTTTCTT
1819
+ GAGCTCC
1820
+ ATTTTGAT
1821
+ GAAAAGG
1822
+ GGTTAGT
1823
+ GCAACAT
1824
+ GACGTT
1825
+ AGATGTT
1826
+ ACCGGT
1827
+ ACAAGCC
1828
+ AGGAGTT
1829
+ GGCCTTT
1830
+ GAGATGG
1831
+ GCCGGT
1832
+ ACACGG
1833
+ ACAAAAAT
1834
+ GAGATGT
1835
+ GGGTCTT
1836
+ GCATGGT
1837
+ GCAAAATT
1838
+ ACGGCT
1839
+ CCTCGC
1840
+ CATCTTT
1841
+ GAGAGAG
1842
+ GTGTGTGT
1843
+ GCTTGAA
1844
+ CTCTCAA
1845
+ CCATGTT
1846
+ ATTTTTTTT
1847
+ GCAAACT
1848
+ ACCATAT
1849
+ GACCGG
1850
+ GCCTCCT
1851
+ AATTTCT
1852
+ GCAGCAA
1853
+ AGGATTT
1854
+ ACTTCCT
1855
+ AATAAAAT
1856
+ GAGATAA
1857
+ CGAAGAA
1858
+ CGGCAG
1859
+ GATGATT
1860
+ ACGGGG
1861
+ CACGGT
1862
+ GAGAGAT
1863
+ CATTGAA
1864
+ GGCCACACAA
1865
+ CAATGTT
1866
+ CCAAGCT
1867
+ GGAAACATAT
1868
+ AATTTTGT
1869
+ AGTTTAA
1870
+ CCATGAA
1871
+ ATTTTCAA
1872
+ GGCCGAA
1873
+ CACAAGG
1874
+ GCACCAT
1875
+ AATATAA
1876
+ CACCCCAC
1877
+ ATATATTT
1878
+ GGAAAGG
1879
+ ACCCGG
1880
+ AGGTTGT
1881
+ AGAAAGAA
1882
+ AGATCAT
1883
+ GTTTGTTT
1884
+ AAAGCAA
1885
+ ATATAAAA
1886
+ GCTTCGT
1887
+ AGCCCAA
1888
+ ATTTCTTT
1889
+ ATTCGG
1890
+ GCTTTGT
1891
+ CGCACT
1892
+ AGGTGAA
1893
+ AAAGAAAA
1894
+ CTATGGCAA
1895
+ CGCGGT
1896
+ GAAAAATT
1897
+ CAGCCTT
1898
+ CACTTAT
1899
+ AAGGTTT
1900
+ CATAAAT
1901
+ GCCAAAT
1902
+ ACACAAT
1903
+ ATGTGAA
1904
+ CAGATCT
1905
+ CATGTTT
1906
+ GAGCTCT
1907
+ CACCACC
1908
+ ATAAACT
1909
+ CATCATT
1910
+ GGCTCAA
1911
+ CGCAGT
1912
+ CGCTAA
1913
+ AGAAGCT
1914
+ GAAAAGAA
1915
+ GATAGG
1916
+ ACCAATT
1917
+ GAGTTGT
1918
+ CCAAAGG
1919
+ GAGCACT
1920
+ GACTGG
1921
+ CACTTGT
1922
+ CATTTTAT
1923
+ ATTATTTT
1924
+ AGCTTAT
1925
+ GCAGGTT
1926
+ CACCAAAA
1927
+ AGAATTTT
1928
+ CCAACTT
1929
+ ATTCATT
1930
+ CACAAAAT
1931
+ CAGCCAT
1932
+ AGCCGG
1933
+ ACGCAT
1934
+ CTCTTCT
1935
+ GTGGTTT
1936
+ GCAATAA
1937
+ GGGGTTT
1938
+ CTATGTT
1939
+ GCCTCAT
1940
+ ACAATCT
1941
+ CCTACC
1942
+ GAGACAA
1943
+ AGTGGAA
1944
+ AGCACAA
1945
+ GAGCCCT
1946
+ GACCTTT
1947
+ CACAACC
1948
+ GTTGCTT
1949
+ GTCCTTT
1950
+ AAATTCT
1951
+ AATGTTT
1952
+ AGTTTCT
1953
+ GACAATT
1954
+ AGTGATT
1955
+ GGACGG
1956
+ ACGTAA
1957
+ AGACCAA
1958
+ GAGTTCT
1959
+ CATGCAT
1960
+ AGATTTTT
1961
+ CAGAGAA
1962
+ AATCAAT
1963
+ GCACCAA
1964
+ CGCGCGG
1965
+ AAACAAAA
1966
+ AAATATTT
1967
+ AGTGAAT
1968
+ ATTGATT
1969
+ GGTTCTT
1970
+ AATTATTT
1971
+ AGTTGGT
1972
+ GCCTTCT
1973
+ CACATGG
1974
+ AGAGGAT
1975
+ ATAACTT
1976
+ GACAGAA
1977
+ AGTCGG
1978
+ GGTTTGT
1979
+ AAAGAAT
1980
+ GGGGAGG
1981
+ ATTCAAT
1982
+ GCAAAGG
1983
+ CTTTCCT
1984
+ CCATGAT
1985
+ GCACGG
1986
+ GACTTAT
1987
+ GAATAGG
1988
+ AGCTAAT
1989
+ AGACCTT
1990
+ GACTTCT
1991
+ GCCCGG
1992
+ ATGTGTT
1993
+ GGTGGAA
1994
+ GGCTCGG
1995
+ CGAGCCT
1996
+ AGATTAA
1997
+ AGCTCAT
1998
+ GAATGTT
1999
+ ATTGAG
2000
+ GACACAT
2001
+ AAAATTAA
2002
+ ACATTAA
2003
+ GCCACAA
2004
+ GGTTCAT
2005
+ CCTTGCCAT
2006
+ AGAGAAAA
2007
+ ATTCGT
2008
+ CTTATTT
2009
+ ACAATTTT
2010
+ GGTAAGT
2011
+ GCTTAAT
2012
+ CGTTAA
2013
+ GTATGAG
2014
+ GAGGGAA
2015
+ GCCAAGG
2016
+ ATAAATAT
2017
+ CATTTCC
2018
+ GCTTTCT
2019
+ GCCGAT
2020
+ CAGAAGT
2021
+ GTGTCTT
2022
+ GGGGGTTGTGT
2023
+ ACTATTT
2024
+ CTCCCAA
2025
+ AGTTTTTT
2026
+ ACGC
2027
+ CAATTGT
2028
+ AACCTTT
2029
+ GAGCAAT
2030
+ ACCGAT
2031
+ ACATTTTT
2032
+ AATCTTT
2033
+ CACATTCTTGG
2034
+ ACCAAAAT
2035
+ AGCCGAA
2036
+ ACAAGCT
2037
+ GCTTCCT
2038
+ CTTGCAA
2039
+ AGAAATCCAA
2040
+ GACTCCT
2041
+ CGTCGCC
2042
+ CTTGTTT
2043
+ CCAACAT
2044
+ ACTTAGG
2045
+ GCCAAGT
2046
+ AGGTTAT
2047
+ GACATCT
2048
+ AAAAAAATT
2049
+ ACGTCC
2050
+ AATAGG
2051
+ CCTTATT
2052
+ GGTGTTT
2053
+ CACACAC
2054
+ GGTTCGG
2055
+ GGGGGGGG
2056
+ CATGTAT
2057
+ ATTTAGG
2058
+ GAGTGAA
2059
+ ACTTGCT
2060
+ ACTCTTT
2061
+ CTTCAAT
2062
+ CGAGGAA
2063
+ GCCCGC
2064
+ CGTAAT
2065
+ GCGACTT
2066
+ CAGGTTT
2067
+ GCCTTGT
2068
+ CTCAAGT
2069
+ ACATGCAT
2070
+ AGGCGG
2071
+ CCTTCCT
2072
+ CTTCTCT
2073
+ GGTGAGG
2074
+ ATATATATAT
2075
+ CACCTCC
2076
+ ACATAAAA
2077
+ GTTGAC
2078
+ CTTTAGAA
2079
+ CCAAGAT
2080
+ AGAGCAT
2081
+ CGCTGG
2082
+ ACCGCT
2083
+ AGTGAC
2084
+ AGCTTCT
2085
+ GGCCATTGAT
2086
+ ACAGAAT
2087
+ GGTTATT
2088
+ ATTTATGT
2089
+ ACTTTCT
2090
+ ATTTAAAT
2091
+ GCACCACC
2092
+ ATATATGT
2093
+ GCGAAAA
2094
+ CACATCT
2095
+ TTTTCC
2096
+ AGTTCCT
2097
+ ACAGATT
2098
+ GAAAAGT
2099
+ CTTTCAAT
2100
+ ACAATGT
2101
+ ACACCAA
2102
+ GAGAGAGG
2103
+ AATTAGG
2104
+ AGCCATT
2105
+ GTAAATT
2106
+ AATTGGT
2107
+ CACCCTT
2108
+ CATCCTT
2109
+ GACTTAA
2110
+ GCTCCGCC
2111
+ TTTTGG
2112
+ ATTTATTTT
2113
+ AGCCGTT
2114
+ CACTCAA
2115
+ ACCTTAA
2116
+ CAAAAGG
2117
+ AGAACTT
2118
+ ATTTCTAA
2119
+ GGGTGTT
2120
+ CACAAGAA
2121
+ CGTAGT
2122
+ GCTCTCT
2123
+ CAGACAT
2124
+ ATTTGATT
2125
+ CGAAATT
2126
+ GGTGTGT
2127
+ ATAAGTT
2128
+ GAAATAT
2129
+ GCTCCAA
2130
+ ACATTGT
2131
+ ACAGCAA
2132
+ GGTTTAT
2133
+ CTTCATT
2134
+ CACCATT
2135
+ CTATCAA
2136
+ AGAAAAAA
2137
+ CTTGAAT
2138
+ AATTACT
2139
+ GAGGCGG
2140
+ AGTATAT
2141
+ GCATGCAT
2142
+ GGCTGAA
2143
+ AACCGT
2144
+ ACGTCT
2145
+ AGCTGAA
2146
+ GGTCCAA
2147
+ CATCACT
2148
+ ACCACAA
2149
+ GCCGTT
2150
+ CAAAAGAA
2151
+ AATTTTAA
2152
+ AGCATAA
2153
+ AGAATGT
2154
+ GCGCACC
2155
+ GCGTAA
2156
+ GAGCAGG
2157
+ CAAATCAA
2158
+ CGTACT
2159
+ ACAGAGG
2160
+ CGCCGAA
2161
+ CCCCCCCC
2162
+ CCTCAAT
2163
+ GTTTGCT
2164
+ CATTTTTGT
2165
+ AAAAACC
2166
+ AGTCCCT
2167
+ GGCCCAA
2168
+ CGGGAT
2169
+ GCTCGC
2170
+ CTATATT
2171
+ GGAGCAA
2172
+ CGTATT
2173
+ GCGCCAT
2174
+ CACTTAA
2175
+ CTTCTAA
2176
+ AAAATTTTT
2177
+ AAATAATT
2178
+ CAGCTTT
2179
+ GAGGAGT
2180
+ GCATTTTT
2181
+ GCATATT
2182
+ AGCCTCT
2183
+ AGAAACC
2184
+ GTGTGTT
2185
+ CACTCAT
2186
+ ACATCTT
2187
+ CAGATAT
2188
+ CGAAGAT
2189
+ ATCCTTT
2190
+ CGATGAA
2191
+ AGAGCTT
2192
+ GACATAA
2193
+ AATTCCT
2194
+ ACTTACC
2195
+ AGGAGGT
2196
+ AGAGATT
2197
+ CACAAAG
2198
+ AGATCTT
2199
+ GAGCTAT
2200
+ CATTGCT
2201
+ AGAATCT
2202
+ GCATTAA
2203
+ GCAGGAT
2204
+ GAGAGTT
2205
+ CGAAGGT
2206
+ CCCTGG
2207
+ GCCACCT
2208
+ CCTTAGG
2209
+ CCTCCAT
2210
+ CTCTTGT
2211
+ AAAATAAT
2212
+ CGAGTTT
2213
+ ACAAACC
2214
+ ATTTTGAA
2215
+ CGCATGG
2216
+ ACTATAT
2217
+ ATAAATTT
2218
+ AAGTCAA
2219
+ GCCATGT
2220
+ CGAAGCT
2221
+ CTCTTTTT
2222
+ CGTCGC
2223
+ GATGCAT
2224
+ ACATATAT
2225
+ ACAAATAT
2226
+ CGAGGAT
2227
+ AGAGTAT
2228
+ GGATCAT
2229
+ GAGTGTT
2230
+ CTATCTT
2231
+ GCAAGCC
2232
+ CAGAGCT
2233
+ AGCATGT
2234
+ CTCCCTT
2235
+ CTAAAGG
2236
+ CACCCAA
2237
+ AATGCTT
2238
+ GAGAGGT
2239
+ GGATTT
2240
+ CCTAGCT
2241
+ CCTAAAA
2242
+ GGTGCTT
2243
+ GCAACTT
2244
+ GACAACC
2245
+ AGACCAT
2246
+ ACTTTTTT
2247
+ AGCAGCT
2248
+ AGTCAAT
2249
+ CATCAC
2250
+ GTTGATT
2251
+ ATAAGAT
2252
+ AGCCTAT
2253
+ ATCCGT
2254
+ CAGCGC
2255
+ ATGTCTT
2256
+ CACCGGACT
2257
+ CTCCAAT
2258
+ GAGAAAAT
2259
+ GAGAACAA
2260
+ CTATGAT
2261
+ GGTTGCT
2262
+ GGTGAAT
2263
+ GCCGAGG
2264
+ GAGGTGT
2265
+ GCAAGTT
2266
+ ATGTATT
2267
+ GGTATTT
2268
+ GCTTTCC
2269
+ AGTCTTT
2270
+ AGATGCT
2271
+ CATTACT
2272
+ AGAAATAT
2273
+ AGCAGCC
2274
+ CGGTCGG
2275
+ GACACTT
2276
+ AAGTGG
2277
+ GGAAACT
2278
+ GACTTGG
2279
+ GCCCAC
2280
+ GCTCGGACTCGG
2281
+ AGTTGCT
2282
+ CGGCGCC
2283
+ GTTAATT
2284
+ CCCCGG
2285
+ CATGCTT
2286
+ AAATACT
2287
+ GCCCAG
2288
+ ACCTTTTT
2289
+ GAGGATT
2290
+ GGATATT
2291
+ CTTTTCTT
2292
+ GGTGGGT
2293
+ CTCTCCT
2294
+ GGATGTT
2295
+ CGGGCGG
2296
+ GTTTTTAT
2297
+ ACATACAT
2298
+ GCATTGT
2299
+ GCGATTT
2300
+ CAATTCC
2301
+ GAGCTAA
2302
+ GTTTTCAA
2303
+ AAATAGT
2304
+ ACAAATTT
2305
+ CTTTACC
2306
+ GAGAACT
2307
+ GTCTGG
2308
+ AATCAG
2309
+ AATATCC
2310
+ CGATGAT
2311
+ GAATGCT
2312
+ GTTGTGG
2313
+ AGATTGT
2314
+ CCATATT
2315
+ AAATGGT
2316
+ CGCGAT
2317
+ AGCAACT
2318
+ CACTAAT
2319
+ CTCCACT
2320
+ GGAAGCT
2321
+ ACACACAC
2322
+ CTTTTGG
2323
+ ATAAAGT
2324
+ GCAATGT
2325
+ CAAAAATT
2326
+ CACAAATT
2327
+ CGAAGCC
2328
+ GGCCGCC
2329
+ GAGTCTT
2330
+ CTACC
2331
+ GAGAGCT
2332
+ GAGTATT
2333
+ CTAAACT
2334
+ CATAATT
2335
+ CAGAACT
2336
+ CTAAGAA
2337
+ CAGCAGG
2338
+ AATGAAT
2339
+ GATGTTT
2340
+ GATTCCT
2341
+ CATGAAT
2342
+ GGATCTT
2343
+ ACAAGGT
2344
+ AGCAGAA
2345
+ GGAGCTT
2346
+ GTCCGGTGCGCC
2347
+ CAAAAACT
2348
+ GATTTTAT
2349
+ ATATGGT
2350
+ AGGAATT
2351
+ CTTTACT
2352
+ GATATTT
2353
+ AGTGGTT
2354
+ CAGAGAT
2355
+ CATCGACC
2356
+ CCAAGGT
2357
+ AGAGTAA
2358
+ ATATACT
2359
+ GATTAATT
2360
+ CTATAAT
2361
+ ACCGTT
2362
+ CACCAAT
2363
+ CCATAAT
2364
+ ACATTCT
2365
+ AGTAGAA
2366
+ CTATCAT
2367
+ CGAATAT
2368
+ ATCTCAA
2369
+ GAAAGAA
2370
+ GATTTCC
2371
+ GAATAAAA
2372
+ GCATAAT
2373
+ ACATGGT
2374
+ GATTGGT
2375
+ AGGGGGAG
2376
+ ACGACAT
2377
+ AGCTGCT
2378
+ GCGAGTT
2379
+ ACTTAGT
2380
+ GTTCTTT
2381
+ CGCCACC
2382
+ GAGGTCC
2383
+ CAAAACAA
2384
+ AGGAAGT
2385
+ GCAATTTT
2386
+ AAATGCT
2387
+ GTGTGAT
2388
+ GACGTGG
2389
+ GCTTGGT
2390
+ ACCAAAG
2391
+ ATTTTATTTT
2392
+ GCATGCT
2393
+ CAGAGCC
2394
+ TTTTTTAT
2395
+ GTTTAGT
2396
+ AAAAAGAA
2397
+ ATATGCT
2398
+ CCTTTAT
2399
+ CGAGGCC
2400
+ CCTAACC
2401
+ GCAAAGT
2402
+ AGCCTCC
2403
+ GCTTGCT
2404
+ ACATGCT
2405
+ ACTAAGT
2406
+ GTTGAGG
2407
+ ATTTGAAT
2408
+ ACGAAAA
2409
+ GCATCTT
2410
+ CACTTTTT
2411
+ GATGGTT
2412
+ GAGTCAT
2413
+ CCTTGCC
2414
+ AGCAGAT
2415
+ CCTACAA
2416
+ GAAATGG
2417
+ CAGCACC
2418
+ ATATAAAT
2419
+ ACCATGT
2420
+ GCAAAAAT
2421
+ CACACCT
2422
+ GCCTCTT
2423
+ ACCCTCT
2424
+ AGCAGGT
2425
+ GTGTGAA
2426
+ AGAGAGT
2427
+ GGAGAT
2428
+ CCTCAGG
2429
+ GTTTGGTT
2430
+ AGCCCGAGT
2431
+ GACAAGAA
2432
+ GAAATCC
2433
+ GAGAGCC
2434
+ GAGATCC
2435
+ CTCTAAT
2436
+ CCTAAAT
2437
+ ACTTTCC
2438
+ GCACTAA
2439
+ GCACATT
2440
+ CAGCAGT
2441
+ GTCTCTT
2442
+ GATTGCT
2443
+ CTTTTTAT
2444
+ GATAATT
2445
+ CCTCGCC
2446
+ CGACCCC
2447
+ GAAATAA
2448
+ GGGTATT
2449
+ GCGACCT
2450
+ GAGCTCAA
2451
+ GCGAGGT
2452
+ GAAATGT
2453
+ CGACCATTTT
2454
+ GGTTGGT
2455
+ GCCTTGG
2456
+ AGCAAGT
2457
+ GTTATTT
2458
+ GAATTCC
2459
+ CAGCCCC
2460
+ ACCTTCGG
2461
+ ACTACTT
2462
+ AGGCAAT
2463
+ GAGTCAA
2464
+ CCTCGGT
2465
+ AGCATTTT
2466
+ GGTGGCC
2467
+ AAAATAAAA
2468
+ CAGCTAT
2469
+ GAAGCAA
2470
+ GAGTTAA
2471
+ GTTAAAT
2472
+ GCAGAGG
2473
+ GACAACT
2474
+ ATTATGT
2475
+ CAGAGTT
2476
+ CAAATAA
2477
+ GAAGGCTAA
2478
+ CATGCAA
2479
+ AGTCCTT
2480
+ CGAGCTT
2481
+ GAGAAATT
2482
+ CTGGTTT
2483
+ CTTCTTTT
2484
+ ACTGTTT
2485
+ GACGAGT
2486
+ CACATCC
2487
+ AGTACTT
2488
+ ACCCAAT
2489
+ CATTCCT
2490
+ AGAAACAA
2491
+ CAGATGT
2492
+ CTCCATT
2493
+ CAGTTAT
2494
+ GAGACAT
2495
+ GGAAGTT
2496
+ ATATATAA
2497
+ AAAATATT
2498
+ GAAGTTT
2499
+ CAGCAAT
2500
+ GAGCCTT
2501
+ GGCTGCT
2502
+ AGCATCT
2503
+ GGCCCGG
2504
+ ATTTTAAAA
2505
+ AACTAAT
2506
+ ACCACTT
2507
+ ACAGAC
2508
+ GGTGCAA
2509
+ ACCTCCT
2510
+ CATAGG
2511
+ CGAACTCC
2512
+ AACAAGT
2513
+ CAGATAA
2514
+ AAATAGG
2515
+ CGACCCCAGG
2516
+ AGCTAGCT
2517
+ CACCTCT
2518
+ ACAGGTT
2519
+ CAAGAAT
2520
+ ACCTTCT
2521
+ ATTACAT
2522
+ GATCGG
2523
+ GATGTAT
2524
+ GAGACTT
2525
+ GATCGT
2526
+ GGATCGG
2527
+ AATATAAT
2528
+ GCCATGG
2529
+ AGTAGTT
2530
+ CACATTTT
2531
+ CCAAACAT
2532
+ CATTAAAA
2533
+ CACTATT
2534
+ GACGGCC
2535
+ CCTAATT
2536
+ ACACTAT
2537
+ GTAAAGG
2538
+ CAACGG
2539
+ CTTAATT
2540
+ GAGTAAT
2541
+ ACAACGT
2542
+ GATGCTT
2543
+ ACGGAG
2544
+ AGACTAT
2545
+ GCATGTGT
2546
+ GAAAACAA
2547
+ GACCCAA
2548
+ ACCCTTT
2549
+ AGGAAGG
2550
+ CACCTAT
2551
+ CACAATTT
2552
+ AATGATT
2553
+ AATATATT
2554
+ GTTTTGGT
2555
+ ACGCGG
2556
+ ACCTGTT
2557
+ CCTTTGT
2558
+ GCTTATT
2559
+ GAGATCT
2560
+ CACCTGT
2561
+ CTCTTGG
2562
+ CACCACT
2563
+ GCACAGG
2564
+ CCAAGCC
2565
+ ACCGTCC
2566
+ GCAATCT
2567
+ GGATGGT
2568
+ CTAACTT
2569
+ AATATGT
2570
+ CCAACGG
2571
+ CCATGGT
2572
+ ACCTCGG
2573
+ GCCTCAA
2574
+ ACACACAT
2575
+ CAGTCAA
2576
+ GCCACAT
2577
+ AGCTTCGG
2578
+ AGTGCTT
2579
+ GTTGCAT
2580
+ CAGAAGG
2581
+ AAAAGCT
2582
+ ACGAATT
2583
+ CACAACAA
2584
+ GAAGAC
2585
+ CGAGATT
2586
+ GGAAACC
2587
+ CACGAC
2588
+ CATGAC
2589
+ GAAGAAT
2590
+ ATTTATAA
2591
+ GAAACAA
2592
+ CTCTTAT
2593
+ GGTGCACC
2594
+ GGAAAGT
2595
+ GCAAGCT
2596
+ GCGAATT
2597
+ GTATATT
2598
+ GTGGCAT
2599
+ CCATCCT
2600
+ ACAGGAT
2601
+ AATCCTT
2602
+ CCAAATTT
2603
+ GCTTTAA
2604
+ ATTTTCGAC
2605
+ AAAGATT
2606
+ AGGGACT
2607
+ GAGGCAT
2608
+ GGGGCTT
2609
+ CGTACC
2610
+ CGCGTGG
2611
+ CTTTTTCT
2612
+ GTTTCCT
2613
+ AACCCAA
2614
+ GGTCCTT
2615
+ GTTACAA
2616
+ CTTGATT
2617
+ ACTCAAT
2618
+ CAGACTT
2619
+ GAATAGT
2620
+ CAGGAGG
2621
+ CTAAGAT
2622
+ AGAAATTT
2623
+ GCGCGCC
2624
+ GCGGCAA
2625
+ GCGACAA
2626
+ CTCTATT
2627
+ GGCCATT
2628
+ AGAGGGG
2629
+ AATATTTT
2630
+ CACACGG
2631
+ GAGGAAGAA
2632
+ GCCTACT
2633
+ ACCTACT
2634
+ AATCATT
2635
+ GACAGCC
2636
+ ATATAATT
2637
+ CGACCAA
2638
+ CTATGAA
2639
+ GCCTTAT
2640
+ ACCAACT
2641
+ CTCTTCC
2642
+ AGCGCCT
2643
+ CTCCTTTT
2644
+ AGGGAC
2645
+ CAGATGG
2646
+ ACTACAA
2647
+ AGCGGAGTT
2648
+ GTTGAAT
2649
+ AGCTCCT
2650
+ CACAGCC
2651
+ CGATTAT
2652
+ AGTGACT
2653
+ GTTCATT
2654
+ GAATTTAT
2655
+ AGGGTTTT
2656
+ GAGGTAT
2657
+ GCCACTT
2658
+ CCTTTCC
2659
+ ATCTGG
2660
+ CAATGGT
2661
+ GTTGCAA
2662
+ GAGCCCC
2663
+ CAGCATT
2664
+ GTGTCAT
2665
+ CGGTGAA
2666
+ GCATTCT
2667
+ AAGGATT
2668
+ GATCATT
2669
+ CTTAAAT
2670
+ AGTGGAT
2671
+ AAAATTGT
2672
+ GTATGAA
2673
+ GCAGGAA
2674
+ GATTTTTTT
2675
+ GGAAGAGG
2676
+ ATTATCC
2677
+ CACAGAA
2678
+ CTAACAT
2679
+ AGCCCAT
2680
+ ACAGCTT
2681
+ GAATGGT
2682
+ CGTTCTT
2683
+ CGTTGCC
2684
+ CTTTGTTT
2685
+ GCTATAT
2686
+ GAGGCTT
2687
+ GATCCAA
2688
+ CGCGTT
2689
+ CTCTCAT
2690
+ CACTTCT
2691
+ GGCTGCC
2692
+ ACCTATT
2693
+ GAGGTGTATGAG
2694
+ ATTATATT
2695
+ GAGAAAC
2696
+ GCAGAAT
2697
+ GGGTGAA
2698
+ GGAGCGG
2699
+ ATTTTATTT
2700
+ GTTGGAT
2701
+ CAAAGAA
2702
+ GGTCATT
2703
+ CAAACTT
2704
+ GAGCAGT
2705
+ AGGAGAT
2706
+ GTTTTCTT
2707
+ CAGCTCC
2708
+ AGCAAAAT
2709
+ CAGACAA
2710
+ GGAAGAC
2711
+ GCCATCT
2712
+ AAAACCT
2713
+ CAGAGGT
2714
+ GAGCACC
2715
+ AGTCATT
2716
+ GAAGAGG
2717
+ GAGCTGG
2718
+ AAATCCT
2719
+ ACTCTAA
2720
+ GCACAAT
2721
+ ACCTCTT
2722
+ GCTTTGG
2723
+ GCCCATT
2724
+ CCTTTGG
2725
+ AGGGATT
2726
+ AAGTGTT
2727
+ GGGTGAT
2728
+ GCCGAGT
2729
+ GAATCCT
2730
+ GGCCACC
2731
+ AGCTCTT
2732
+ AAAATGG
2733
+ AGGTTAA
2734
+ AATTGCT
2735
+ AGAGGGT
2736
+ AGGATAT
2737
+ CAAAACAT
2738
+ ACAAACAA
2739
+ GTGTAAT
2740
+ AAAGCTT
2741
+ CTCTGAT
2742
+ CAAACAT
2743
+ CCTTTCT
2744
+ GGAAGCC
2745
+ CACTCCT
2746
+ GCTGAC
2747
+ AGAGGCT
2748
+ AGATAAAA
2749
+ ATTACTT
2750
+ CACCGCC
2751
+ ACCTCAT
2752
+ CTCTGTT
2753
+ GTATGTT
2754
+ ATTTTTTAT
2755
+ CAAAACTT
2756
+ ATTATAA
2757
+ GAAATTTT
2758
+ GGAGCCT
2759
+ GGTTTCT
2760
+ AGAGGCTCAT
2761
+ ACGAGTT
2762
+ AAACTTTT
2763
+ GTTTTTGT
2764
+ CACTTGG
2765
+ GAAGCTT
2766
+ AGATTCT
2767
+ GAAGATT
2768
+ GCCTTCGG
2769
+ CGCCTCC
2770
+ GTGTACT
2771
+ ACGTGTT
2772
+ GAGCCAT
2773
+ CAATAAAA
2774
+ AGTCGAT
2775
+ GAAACAT
2776
+ GCAGCTT
2777
+ GACCATT
2778
+ GAGAACC
2779
+ AATCGT
2780
+ AATGAC
2781
+ GTTTATTT
2782
+ CTAAGTT
2783
+ AGGTGGT
2784
+ AAAATCC
2785
+ GAGTGAT
2786
+ GAGGGTT
2787
+ AGTACAA
2788
+ GCCTTCC
2789
+ GTATGAT
2790
+ AGATCCT
2791
+ CCTTGGT
2792
+ ACCATAA
2793
+ AGGTTTTT
2794
+ AGCGAGG
2795
+ CCATGCT
2796
+ ACACTCT
2797
+ AGAGAGAA
2798
+ AGTGTAA
2799
+ GGAACTT
2800
+ AGGCAC
2801
+ CGACGAC
2802
+ CATTAATT
2803
+ ACATATTT
2804
+ ACAGAAAA
2805
+ AGTGCAA
2806
+ GGCTATT
2807
+ CAATACT
2808
+ AGTCCAA
2809
+ ACTTAAAA
2810
+ AGCTTCC
2811
+ GATCAGT
2812
+ GCAGCGG
2813
+ GCTAAGT
2814
+ AACTCAA
2815
+ ATCTCTT
2816
+ ACAGAGT
2817
+ CGATCTT
2818
+ AGCTGAT
2819
+ AGAAGGT
2820
+ ACCCAC
2821
+ GTTTCTTT
2822
+ ACTAGTT
2823
+ GAGGTAA
2824
+ AGCTGTT
2825
+ CAAGTGAA
2826
+ GTCCATT
2827
+ GTGTATT
2828
+ CTCCCAT
2829
+ ACATTGG
2830
+ ATTTTTTTTT
2831
+ CAATTTAT
2832
+ GCCATAT
2833
+ AATAATTT
2834
+ AGATGGT
2835
+ ACGATTT
2836
+ CACAGTT
2837
+ CACTGTT
2838
+ GTGTCAA
2839
+ GTATCAA
2840
+ AAATAAAAT
2841
+ ACACACT
2842
+ AGGGAGG
2843
+ CGGTGAT
2844
+ ATTATTATTATT
2845
+ ACCAACC
2846
+ CATTTTTTT
2847
+ CATTTGG
2848
+ GCACCCC
2849
+ CTTCCGG
2850
+ ACCATCC
2851
+ ACCACCT
2852
+ CTTTCCTT
2853
+ AATTTTTTTT
2854
+ ACGGAC
2855
+ AATAATAATAAT
2856
+ AGAGACT
2857
+ CATTGGT
2858
+ AATAAATT
2859
+ AGCTATT
2860
+ CCCTCAT
2861
+ CTTTAGT
2862
+ CGACCCAGG
2863
+ GCAACGG
2864
+ GGAGGCC
2865
+ GACATCC
2866
+ GAAGGAT
2867
+ GACCTAT
2868
+ CTCAACC
2869
+ AGAAACAT
2870
+ GACAAATT
2871
+ CTTTTCAA
2872
+ CTTTTGTT
2873
+ ACACTAA
2874
+ CAGAACC
2875
+ GGAGAAT
2876
+ CACCCAT
2877
+ CCTTTAA
2878
+ GCCTCGT
2879
+ GGTATGT
2880
+ GAAAACAT
2881
+ GACTCGG
2882
+ ACGAAAT
2883
+ GTAACAA
2884
+ CTTTCTCT
2885
+ GCTAGGT
2886
+ GCAATCC
2887
+ CAATCCT
2888
+ GGTTAAT
2889
+ AGGAAGAA
2890
+ CAGCTCT
2891
+ CGCGAC
2892
+ AGTTTGG
2893
+ CACCCCT
2894
+ ATTTCATT
2895
+ ACTTTTAT
2896
+ ACCTAAT
2897
+ ATTGCTT
2898
+ GCTACAA
2899
+ CTTTAAAA
2900
+ ACGCAC
2901
+ GACTAAT
2902
+ GATATGT
2903
+ GCTTTTTT
2904
+ CATCAGG
2905
+ GGCCGAC
2906
+ GTATAAT
2907
+ AGGATAA
2908
+ AGTAGAT
2909
+ GGCCACT
2910
+ ACACAAAA
2911
+ GAAGGTT
2912
+ GCCGAC
2913
+ AAGTAAT
2914
+ ACCTTCC
2915
+ GCAGTGG
2916
+ AGTACAT
2917
+ ATTTAGTT
2918
+ GAGGAAGG
2919
+ CGAGCAA
2920
+ ACCATGG
2921
+ CAGCGCC
2922
+ CGAACAA
2923
+ GGATGCT
2924
+ CCAAACTT
2925
+ CACCAGG
2926
+ CATCCAT
2927
+ CCTCAC
2928
+ GGTCTGG
2929
+ AATTATAT
2930
+ GGTGGTGCACC
2931
+ AATTTGG
2932
+ CGAATGT
2933
+ CGCTTTT
2934
+ AAAAACAA
2935
+ GTTTAGG
2936
+ GGATAAT
2937
+ AGGTCTT
2938
+ CACTCTT
2939
+ CCCTCTT
2940
+ GTTTTGTT
2941
+ AGAAGAG
2942
+ ACACACC
2943
+ ACTCTCT
2944
+ GACCTTTT
2945
+ CAGTTGT
2946
+ GCGCCAA
2947
+ ACAAAAAA
2948
+ GGATCCT
2949
+ GCTCAGG
2950
+ AGCCATGAA
2951
+ CTCCCCT
2952
+ GATCAC
2953
+ GCAAGAGG
2954
+ CGACGAA
2955
+ CATGATT
2956
+ GCACTGT
2957
+ CGACTCC
2958
+ CAGGTAT
2959
+ CATCCAA
2960
+ CGGAGTT
2961
+ CATATAA
2962
+ ACGCGT
2963
+ ACTCATT
2964
+ AAAAGGAA
2965
+ CGTAGG
2966
+ CGATCAA
2967
+ ATTTTTGACCAA
2968
+ GACAGTT
2969
+ AGCTAGT
2970
+ ATTGGTT
2971
+ CAGTCTT
2972
+ GAGGGGT
2973
+ GCGGTGG
2974
+ ACAAAGTT
2975
+ CTCAACT
2976
+ GGTTTGG
2977
+ ACCAAATT
2978
+ GCCAATT
2979
+ GACTGAA
2980
+ GTGGAGG
2981
+ GTTATAT
2982
+ ATTTGTAA
2983
+ ATTTGTTTT
2984
+ ACTAAATT
2985
+ AGTGTGT
2986
+ AGTAAGT
2987
+ ACACTTTT
2988
+ AAAGTTTT
2989
+ ACTATAA
2990
+ ACGCAG
2991
+ AGTCACT
2992
+ AGCTCGG
2993
+ ACCTGAA
2994
+ GATTTATT
2995
+ GCCTTTTT
2996
+ AGGTATT
2997
+ CCATACC
2998
+ GGTTAGG
2999
+ GATGAGG
3000
+ GAATTGG
3001
+ AGTGCAT
3002
+ GGTGATT
3003
+ CGTCTCC
3004
+ GCTGGGG
3005
+ AGTCTCT
3006
+ GCTCTTT
3007
+ AGTATAA
3008
+ ATGTGTGT
3009
+ CAAATAAT
3010
+ AGAGTTTT
3011
+ GAATAAAT
3012
+ CTAAATTT
3013
+ CCTCCGT
3014
+ GAGTGGT
3015
+ GAGGAAAA
3016
+ AGCCTTCGGT
3017
+ CATCACC
3018
+ CCTCATT
3019
+ CTTTTTGT
3020
+ GCTGCTT
3021
+ CATTTTGT
3022
+ AGGTAAT
3023
+ GATTTTGT
3024
+ GGAGATT
3025
+ GTATCTT
3026
+ CGCAGCC
3027
+ GAAGGCAA
3028
+ AATTTTCT
3029
+ GGTGCAT
3030
+ ACTCCAA
3031
+ CGAGGCT
3032
+ AACCAAT
3033
+ CCTCCCT
3034
+ CGTCGGT
3035
+ CACTGAT
3036
+ AGCAACC
3037
+ CCTATTT
3038
+ AATTTATT
3039
+ ACATTTAT
3040
+ GTTTGAAT
3041
+ GGGGAAT
3042
+ GGTAATT
3043
+ CTCTGAA
3044
+ AGGTTCT
3045
+ CGGGCGAGG
3046
+ CGCGCGC
3047
+ GATGGAT
3048
+ AGTAACT
3049
+ AGTTAATT
3050
+ GATCTTT
3051
+ GTTTAATT
3052
+ GCAACCT
3053
+ AAAGCAT
3054
+ AGTGAGT
3055
+ GAGGTGG
3056
+ ATTATCT
3057
+ ATATGAAT
3058
+ CACCTACGG
3059
+ CTCTAGG
3060
+ AGTTTTAT
3061
+ AGCTACT
3062
+ AGTACCT
3063
+ AGTCCAT
3064
+ AGCCAAT
3065
+ AAAACAAAT
3066
+ AAAAACAT
3067
+ GGTGGAT
3068
+ CTTCTTCTT
3069
+ CAGTTCT
3070
+ AAAATCAA
3071
+ CAGAAGAA
3072
+ GCAGGCT
3073
+ CGCTCGG
3074
+ GACCCAT
3075
+ CGTTCAT
3076
+ CTTTATTT
3077
+ CGATTCC
3078
+ CAGTTTTT
3079
+ ACCCGAA
3080
+ ACAAACTT
3081
+ CAATTTGT
3082
+ CGAGAGG
3083
+ CACCTTTT
3084
+ CCCAACC
3085
+ GAATTTGT
3086
+ GTTTTATT
3087
+ AGCTTAA
3088
+ AAGTGAT
3089
+ AAGTATT
3090
+ GACTATT
3091
+ ATGTATGT
3092
+ CAGGGTT
3093
+ CTCTGCT
3094
+ CTTTGATT
3095
+ ATTTTGCT
3096
+ GTTTTTAA
3097
+ GTTTGATT
3098
+ GGGGGCT
3099
+ CAATTCAA
3100
+ CTTTTATT
3101
+ GAGAATTT
3102
+ ACCATCT
3103
+ GAAAAAGG
3104
+ GCACTCC
3105
+ AAAGATAT
3106
+ GGTACCT
3107
+ AGTCAC
3108
+ GCCTAAT
3109
+ CAATGCT
3110
+ ACATAAAT
3111
+ GATTTGAT
3112
+ CCTGAC
3113
+ GTCTCAA
3114
+ GCGTTTT
3115
+ ACGAAGT
3116
+ ACTATTTT
3117
+ GGTAAAT
3118
+ GAAAGAT
3119
+ CTTTTGCT
3120
+ AAAATTCT
3121
+ CAGGCAA
3122
+ GGTTGATT
3123
+ AGTTTCC
3124
+ GGTTTAA
3125
+ GCAGTAT
3126
+ CAAGGCAA
3127
+ AGAGTGT
3128
+ AATAACAA
3129
+ CAGAAAAT
3130
+ CAGACCT
3131
+ CGCAGGT
3132
+ GGTCGAC
3133
+ GGCCAGG
3134
+ CGGCTCT
3135
+ CCTCACT
3136
+ CGAACTT
3137
+ CGTTTCT
3138
+ CATTTTCT
3139
+ GGTCCCT
3140
+ CTAAACC
3141
+ GCACTCT
3142
+ GACTTTTT
3143
+ GTGGCAA
3144
+ GATTAGG
3145
+ CACAGCT
3146
+ GGCTCACC
3147
+ GCATATAT
3148
+ ACTCCAT
3149
+ CGCCTTT
3150
+ CTTTTGAA
3151
+ CTATAAAT
3152
+ CTCCGCC
3153
+ GGGGGAA
3154
+ AGCAAGG
3155
+ CCCCCAA
3156
+ CGTTTAT
3157
+ GAGTTGG
3158
+ CACCAAAAT
3159
+ GCTTAATT
3160
+ CGCCCTT
3161
+ GAATGAAT
3162
+ CAAATCTT
3163
+ ACTAAAAT
3164
+ ACAGCAG
3165
+ AAGTCAT
3166
+ GTGTGGT
3167
+ ATTTCAAT
3168
+ CTCATCT
3169
+ AATGCAA
3170
+ ATTTTAATT
3171
+ CTCTTAA
3172
+ AGAGACC
3173
+ ATTTAATTT
3174
+ ACAAATGT
3175
+ ATATCCT
3176
+ ACTTGTTT
3177
+ ACACCCC
3178
+ GTTTTTCT
3179
+ GACAGCT
3180
+ CCGTAGGTGTT
3181
+ CGGCAC
3182
+ GACAGGT
3183
+ CACCAAAT
3184
+ ACCCATT
3185
+ CGACCAT
3186
+ GCCCAAT
3187
+ CAGCACT
3188
+ GAGACAC
3189
+ GACGAAT
3190
+ CACTTCC
3191
+ GGCTGAT
3192
+ GGTCAC
3193
+ AGTGGAG
3194
+ CTCCCCCT
3195
+ CAGATCC
3196
+ AGTAAAAT
3197
+ AGGCCTT
3198
+ CAAATGAA
3199
+ AGAAGCC
3200
+ CATTAAAT
3201
+ ACAAACAT
3202
+ CGGCGGT
3203
+ GAACAGT
3204
+ GCGAAGG
3205
+ GAATACT
3206
+ CGTTCATGGCT
3207
+ ACAACCT
3208
+ CACAAAC
3209
+ GCGACGT
3210
+ GATGACC
3211
+ AAAAGGT
3212
+ CAAATCT
3213
+ ACTTGCC
3214
+ GTCCGG
3215
+ GCATAATT
3216
+ ACAACAAT
3217
+ GAAATAAT
3218
+ GTTTACT
3219
+ AGTGTAT
3220
+ AATTTCC
3221
+ AGCGGAT
3222
+ CGTCGAT
3223
+ GTTTGCC
3224
+ CATACAT
3225
+ CACAGGT
3226
+ ATGGATT
3227
+ GCTCACT
3228
+ ACGGAGG
3229
+ CATTTGAT
3230
+ AGATACT
3231
+ CTATAAAA
3232
+ ACGAGGT
3233
+ GGGGGAT
3234
+ GTTGTAA
3235
+ GCTCAAT
3236
+ GGTCCCC
3237
+ ACGACTT
3238
+ GCATGCC
3239
+ GCTCATT
3240
+ GACGACC
3241
+ GCAATGG
3242
+ GTGGGAA
3243
+ GAGGGAT
3244
+ GGACAAT
3245
+ ATTTTTGG
3246
+ GAGATTTT
3247
+ CGAAGTT
3248
+ GAAATCAA
3249
+ CAATTGG
3250
+ CAGTGTT
3251
+ CACAGAT
3252
+ ACAGGAA
3253
+ GACCTCT
3254
+ CAAATATT
3255
+ CGAGGGT
3256
+ CTTTTCAT
3257
+ GCAGTCT
3258
+ GACACAC
3259
+ CAGTGGT
3260
+ CAGAAATT
3261
+ GAAAAAGAA
3262
+ GCATCCT
3263
+ AGCCACC
3264
+ GCCGCCGT
3265
+ ACAGCAT
3266
+ GAATAATT
3267
+ GACAAAG
3268
+ CTTTAATT
3269
+ GACTCAT
3270
+ CAGTTGG
3271
+ GCAAACAT
3272
+ CTAAAGT
3273
+ AGAGAAAT
3274
+ GCTAAAT
3275
+ GCACTAT
3276
+ CAGGATT
3277
+ ATTATAAT
3278
+ AGGTCAA
3279
+ GACCAAT
3280
+ CAGCCCT
3281
+ AAAAATGG
3282
+ CGACTAT
3283
+ GGAAGGT
3284
+ GTGGAGT
3285
+ CGAAACC
3286
+ CGACACC
3287
+ ACAGACT
3288
+ GTTCAAT
3289
+ GACAGAT
3290
+ GCCGAG
3291
+ ATTAAATT
3292
+ GAAACTT
3293
+ ACTAGAT
3294
+ GTTGGTT
3295
+ GGGTCAA
3296
+ AGAACCT
3297
+ GGCCCAT
3298
+ GCAAACC
3299
+ CAATTAAT
3300
+ GCCAACT
3301
+ GCGAGAT
3302
+ CAGTTAA
3303
+ GCAGCAG
3304
+ GCCCTTT
3305
+ GTTTTTGG
3306
+ GTTTATAT
3307
+ AGAAATAA
3308
+ GCTATTT
3309
+ GCGCAGG
3310
+ GAAGCAT
3311
+ CGATTAA
3312
+ ATTCACC
3313
+ ATTCCAA
3314
+ GGTCGC
3315
+ AGAGGCC
3316
+ AGGTGCC
3317
+ ACATACT
3318
+ GATCCTT
3319
+ ATTTTTCC
3320
+ CTCATCC
3321
+ GCTCCCC
3322
+ GATCAG
3323
+ ATTAAAAT
3324
+ AGTTAAAA
3325
+ AGTATGT
3326
+ GTAACAT
3327
+ GATGTGG
3328
+ CGAGTAT
3329
+ GGGGCGG
3330
+ GCAGTGT
3331
+ GGATAGG
3332
+ CACCTAA
3333
+ GATTTGTT
3334
+ GAATACC
3335
+ GAGGGCT
3336
+ CCAAGAG
3337
+ CACTCGT
3338
+ ATTAATTT
3339
+ AGGAACT
3340
+ CAGTAGT
3341
+ GCATTCC
3342
+ ACTAACT
3343
+ GCTGCAA
3344
+ GTTTCTAA
3345
+ CAAATGG
3346
+ CTTCACC
3347
+ AATATGAA
3348
+ GCGGTCC
3349
+ ATATGCC
3350
+ GCAGGGG
3351
+ GGCTAGG
3352
+ CGCAAAA
3353
+ GACATTTT
3354
+ ATCTCAT
3355
+ CGACGCC
3356
+ GGTTAAAA
3357
+ GCGAGAA
3358
+ AGCCTAA
3359
+ AAACAAAT
3360
+ AATTGATT
3361
+ CTTCCAA
3362
+ GCAGGCC
3363
+ CACTACT
3364
+ AGAGATTT
3365
+ GAAGGAA
3366
+ ATTAGTT
3367
+ ACCAGCC
3368
+ GGTATAT
3369
+ CGAGGGG
3370
+ GGAGGCT
3371
+ GCTAGCT
3372
+ CATTTCAT
3373
+ GACAATTT
3374
+ ATTACAA
3375
+ AGGATGT
3376
+ GCGACAT
3377
+ AGTGACC
3378
+ GCGCGAA
3379
+ GCTCCAT
3380
+ GGAGAAAA
3381
+ CCAACCTT
3382
+ ACCAAGG
3383
+ ATGGAAT
3384
+ CGGCGGCGG
3385
+ GACTTCC
3386
+ GTAAGCCT
3387
+ AGGTCAT
3388
+ AATTAAATT
3389
+ CTCAATTT
3390
+ GTTGGAA
3391
+ CCTCGAT
3392
+ CTCATAA
3393
+ GACCTCC
3394
+ GATTGAGT
3395
+ ACAATCC
3396
+ GGTCGAA
3397
+ CAGGATAA
3398
+ GAGCTGT
3399
+ ACATGGTT
3400
+ AGCGCTT
3401
+ GTTTTGAT
3402
+ GTTTGGGT
3403
+ CGGCCAT
3404
+ GAATTTAA
3405
+ AGTCAG
3406
+ GACACCT
3407
+ ACATACC
3408
+ GACAAAAT
3409
+ GCGATGG
3410
+ GTAACTT
3411
+ CTTTCTTTT
3412
+ ATGGTTTT
3413
+ CCAAATAT
3414
+ AGTAGTGG
3415
+ AGCTCACT
3416
+ CGTCAC
3417
+ AGGTGCT
3418
+ CGCAAGG
3419
+ GTTTTGAA
3420
+ CGCCTCT
3421
+ AGACTCT
3422
+ ATTTAAATT
3423
+ CAGTAAT
3424
+ ACATGTTT
3425
+ GTAACACC
3426
+ CAAATCAT
3427
+ CGGCGAT
3428
+ CAGGTAA
3429
+ CTCCGAA
3430
+ CAGCTAA
3431
+ AGCGGTT
3432
+ ACGACAA
3433
+ ATTTACC
3434
+ AACAACT
3435
+ GCAGCAT
3436
+ CGTTGAA
3437
+ CAGTGAA
3438
+ ACTTCGT
3439
+ GCCATAA
3440
+ GCGCCTT
3441
+ GGCTCCT
3442
+ ATTTTAGT
3443
+ GCAGATT
3444
+ GCTTACC
3445
+ CAACAAT
3446
+ CCTTCAG
3447
+ CGCGGCC
3448
+ GGTGACC
3449
+ GAGTTCC
3450
+ GCCAGAA
3451
+ AATACTT
3452
+ GTTGGGT
3453
+ ACTTTGG
3454
+ GCCACGT
3455
+ GTCCCTT
3456
+ GATTAAAT
3457
+ CGTGAG
3458
+ CGAGTCC
3459
+ ACAGTAT
3460
+ GGGGCAA
3461
+ AAAAATGT
3462
+ GGTGAGT
3463
+ AACTCAT
3464
+ CGAGAAT
3465
+ GGAGGGT
3466
+ ACATTTGT
3467
+ ACTCAGG
3468
+ GCGCCCC
3469
+ CCTGCTT
3470
+ GAGCTCTT
3471
+ CCTTGCTT
3472
+ GGCCGACC
3473
+ CATTCTTT
3474
+ GATTAGT
3475
+ CAGAAAG
3476
+ GACTGTT
3477
+ AGCTTCTT
3478
+ GTGTGCT
3479
+ CAATAATACC
3480
+ ACGGTTT
3481
+ CAAAGTT
3482
+ GTATCAT
3483
+ GTCCACT
3484
+ GAGATGAA
3485
+ AGCCACT
3486
+ GACTCTT
3487
+ CAGCTGG
3488
+ ATTTGGTT
3489
+ AGCTAGG
3490
+ CTCTACT
3491
+ GGCTAAT
3492
+ CGTTGAT
3493
+ CAGTGAT
3494
+ AAATGCTT
3495
+ CAAGGAA
3496
+ ATTTGGAT
3497
+ CGGCCAA
3498
+ GATTTAAT
3499
+ CGTTTCC
3500
+ GCATGTTT
3501
+ ACGCGC
3502
+ AGATATAT
3503
+ CGGGGAT
3504
+ AGCCGCC
3505
+ AATTCATT
3506
+ CCTTACT
3507
+ CTTTTTAA
3508
+ CGAGCGG
3509
+ ACAAAGAT
3510
+ GTGTGTTT
3511
+ ACACATAT
3512
+ GCCAACC
3513
+ CGCGGGG
3514
+ CCCCATT
3515
+ GCCTGCT
3516
+ GCGAAGT
3517
+ ACCGAGG
3518
+ GCTTAGT
3519
+ AATATCAT
3520
+ ACATATGT
3521
+ CATTTTAA
3522
+ CGTATGT
3523
+ ACCTTGG
3524
+ GCCCTGG
3525
+ GAATCGG
3526
+ GCGGAGG
3527
+ CACTCGG
3528
+ CAGGTGT
3529
+ ACATAATT
3530
+ CGGTCAA
3531
+ CGAATCT
3532
+ GCCTAGG
3533
+ AAAAATAAAA
3534
+ GTCCCAA
3535
+ CTAAATAT
3536
+ CGTTTGT
3537
+ CAATTCTT
3538
+ GCATACT
3539
+ AGTATCT
3540
+ AAATGTTT
3541
+ CAGAATTT
3542
+ ACGAAGG
3543
+ GATGCAA
3544
+ ATTTTCCT
3545
+ AGGCATT
3546
+ ACATGTAT
3547
+ GCTGAG
3548
+ GATGGAA
3549
+ GAATGACC
3550
+ ACGTTTT
3551
+ GGTGTGG
3552
+ CCAACCT
3553
+ CGGCCGCC
3554
+ GATGACT
3555
+ GTAAGAA
3556
+ CAATAAAT
3557
+ ACCGGTT
3558
+ CTTTTCTTT
3559
+ CATATCAT
3560
+ AGCATGG
3561
+ CTTGGCC
3562
+ CCTTGTTT
3563
+ AGCCCGG
3564
+ CAAACAA
3565
+ AATAACAT
3566
+ GAGCCGAGG
3567
+ GGTCTTT
3568
+ GGTGGCT
3569
+ CCTTCGAA
3570
+ CAGTCAT
3571
+ AGACTTTT
3572
+ CGGCACC
3573
+ GATTATGT
3574
+ CTTGGTT
3575
+ CCTCACC
3576
+ CGATTCT
3577
+ GTTGGGG
3578
+ CAATTTCT
3579
+ ACCCCTT
3580
+ CGGCCCC
3581
+ GAATATTT
3582
+ GCGCTCC
3583
+ CTCTCTCC
3584
+ CATTATTT
3585
+ ACAATGG
3586
+ AGGCTTT
3587
+ AATTATAA
3588
+ CAAAAACAT
3589
+ GATAACT
3590
+ CTCTCTTT
3591
+ AAGTCTT
3592
+ AGGACTT
3593
+ AATCTAA
3594
+ CAATTGGTAT
3595
+ ACCCGC
3596
+ GATGGGT
3597
+ CTCTCGT
3598
+ GGTCAGG
3599
+ CCATCCTT
3600
+ CATTTCAA
3601
+ AGTTACT
3602
+ CATGACC
3603
+ CATTATAT
3604
+ GGTTGCC
3605
+ GCGCCGT
3606
+ GGACATT
3607
+ AGGAACC
3608
+ CTGTCAA
3609
+ CACGAAT
3610
+ GAAATATT
3611
+ GCGAACC
3612
+ AGTCTAA
3613
+ CAATACAA
3614
+ CGGAGAT
3615
+ CAGAAAC
3616
+ CTTGGAT
3617
+ GCTTGCC
3618
+ AATTAATTT
3619
+ AGACGAA
3620
+ ATGGCAT
3621
+ ACACGAA
3622
+ CTTTCGT
3623
+ ATTTTAAAT
3624
+ GCTGGAA
3625
+ CACGGCC
3626
+ CACGAG
3627
+ GCTTTTAT
3628
+ ATTTGAGT
3629
+ ATTTGTGT
3630
+ CGTCGTT
3631
+ GCGACGG
3632
+ GAAATGAA
3633
+ ACAAAGAA
3634
+ GGGGATT
3635
+ ACATATATAT
3636
+ GAATATAT
3637
+ GGTGTGGT
3638
+ AAAAGAAAA
3639
+ CGACCGT
3640
+ GTGGAAT
3641
+ GTTCTCT
3642
+ GTAAACT
3643
+ GATGTGT
3644
+ CGTAGCT
3645
+ GTTATGT
3646
+ GCGAGCC
3647
+ GGCTCAT
3648
+ GCTCCCT
3649
+ GATAAAAT
3650
+ CATTTCTT
3651
+ CTTTTTCC
3652
+ GAAGAAGAA
3653
+ AGAATGG
3654
+ GGACGAA
3655
+ GATATAA
3656
+ AGCTAGCC
3657
+ ACTTACT
3658
+ ACCATTTT
3659
+ ACGGCGG
3660
+ ACATTCC
3661
+ ACAAATAA
3662
+ AGAATTTTT
3663
+ GGTTCCT
3664
+ GCCAGAT
3665
+ CAATAGT
3666
+ CGCGGCGG
3667
+ AGGAAAAT
3668
+ CTTCACT
3669
+ GGGTGGT
3670
+ AAAAAAGAA
3671
+ CACGACC
3672
+ GTATGTTT
3673
+ AGAAGAC
3674
+ CGCATCC
3675
+ CATAAAG
3676
+ CTTCCCC
3677
+ GCAAAAAA
3678
+ GCTATGT
3679
+ CACGAGG
3680
+ AGCGAGT
3681
+ ACCACAC
3682
+ CAAGTTT
3683
+ GTGGGCC
3684
+ GACGGGG
3685
+ GCTCCTT
3686
+ GGTCAGT
3687
+ GAGGTCT
3688
+ CGCCGCCGCC
3689
+ GATGAGT
3690
+ CGACAAT
3691
+ AATTTTATT
3692
+ AGTTAGT
3693
+ GATTACT
3694
+ AAATGAAT
3695
+ GGCTACT
3696
+ CAATTCAT
3697
+ ATTTTACT
3698
+ CTTTCGG
3699
+ GCGCGCGC
3700
+ GTCTCAT
3701
+ CTTGAGG
3702
+ AGTTGCTT
3703
+ CTTATAT
3704
+ GCTATAATT
3705
+ CATTCATT
3706
+ CCATGCC
3707
+ CGGGACC
3708
+ AGCAATTT
3709
+ GCACACAT
3710
+ ACCAAAC
3711
+ GAATTTCT
3712
+ GGTAGCT
3713
+ AGCCTTTT
3714
+ GCCTATT
3715
+ AATTTAAT
3716
+ GACCCCT
3717
+ AGAAGAGG
3718
+ GATTTTCT
3719
+ CTTGGAA
3720
+ GCTTTCAA
3721
+ AGGCCAA
3722
+ ATTTGATTT
3723
+ AAAAATAAT
3724
+ CCTTTTAT
3725
+ GAGCGAG
3726
+ GGTTTCC
3727
+ CATTTAAT
3728
+ CCTTCCTT
3729
+ ATATAGT
3730
+ ACAGTTTT
3731
+ GACTACT
3732
+ GAAAAACT
3733
+ AGATTTAT
3734
+ GAATTGAA
3735
+ AGGAGCT
3736
+ CAATCAAT
3737
+ CATATGT
3738
+ AAGTGAA
3739
+ GGAGGGG
3740
+ GTTTGAG
3741
+ AATTGTGT
3742
+ CCCTCAA
3743
+ CGCCCAA
3744
+ GGCCAAT
3745
+ ATTTCTAT
3746
+ CTCAAGG
3747
+ CAAATGTT
3748
+ GGTACTT
3749
+ CACACTAT
3750
+ ACAGACC
3751
+ AATAAGAA
3752
+ GCATTGG
3753
+ CTTTTGAT
3754
+ CACTGCT
3755
+ ACAGTAA
3756
+ GTTTAAAA
3757
+ AAATAAATT
3758
+ GCCTTAA
3759
+ AAGAATTT
3760
+ AACTGG
3761
+ CTTGTGT
3762
+ ACAGTGG
3763
+ CGATTTTT
3764
+ GTTATAA
3765
+ CATACAA
3766
+ CTTCTCCT
3767
+ AGACTAA
3768
+ CACTGAA
3769
+ GCTTCTTT
3770
+ GTGGATT
3771
+ AAGAAGT
3772
+ CGTCGAC
3773
+ GCCATCC
3774
+ ACTTAATT
3775
+ ATATGATT
3776
+ AACTAAAA
3777
+ GCAAGAG
3778
+ CTCTCCCC
3779
+ AGGCTAA
3780
+ GTTTCGG
3781
+ AGCTTGG
3782
+ CCTTCCCC
3783
+ AGACACT
3784
+ CACTAAAA
3785
+ GACCACC
3786
+ GTTTTCAT
3787
+ ATTTTTATT
3788
+ AGATGCAT
3789
+ GACAACAA
3790
+ AACTATT
3791
+ AGCATCC
3792
+ CCTTCTCC
3793
+ AATCCAA
3794
+ ACAATTAT
3795
+ ATATGTAT
3796
+ CAGTATT
3797
+ CTTTTCTTTT
3798
+ CGAGACC
3799
+ AGAATTAT
3800
+ CTTTGAAT
3801
+ AAAAATCAT
3802
+ GCATTTAT
3803
+ ATTATTATT
3804
+ CGGTGGT
3805
+ GACACGT
3806
+ CCAAAGTT
3807
+ AGGGGAA
3808
+ CGCGAGG
3809
+ AACTCTT
3810
+ CTTTGGAA
3811
+ AAATCAAT
3812
+ GGCTGTT
3813
+ AGAGTCT
3814
+ GGCTCTT
3815
+ GAGTAGT
3816
+ GATATGG
3817
+ AGGGCAT
3818
+ ATTTAAAAT
3819
+ ACCTGCT
3820
+ GACCACT
3821
+ CATCGAT
3822
+ AGGTTGG
3823
+ CGGAGGT
3824
+ CATTGATT
3825
+ GCTTCTCC
3826
+ ACATTCAA
3827
+ AAGTACT
3828
+ ATTATCAA
3829
+ GCGCTGG
3830
+ ACCGAAT
3831
+ ATTTTAGG
3832
+ ATTTGTAT
3833
+ ATCTATT
3834
+ GCACACT
3835
+ GACGGAA
3836
+ GGGGGAG
3837
+ AGAATCC
3838
+ GAAAATAGCCAT
3839
+ AGCTCGT
3840
+ CATTAGT
3841
+ CCTGTTT
3842
+ AATGCAT
3843
+ CACTGCC
3844
+ ACCTGAT
3845
+ GGCCGGCC
3846
+ CAGGGAA
3847
+ CACGCTT
3848
+ GATTTTAA
3849
+ CTTCCAT
3850
+ AGCGACT
3851
+ GATGTCAT
3852
+ ACTTGATT
3853
+ AACCGG
3854
+ AGCGGCT
3855
+ GCGTGGT
3856
+ AAATCCAA
3857
+ AAAAAAAATT
3858
+ GTTCCTT
3859
+ ACATAGT
3860
+ AATCCAT
3861
+ CCTGAGG
3862
+ GCGAGCT
3863
+ CGTCACC
3864
+ CGTCGAA
3865
+ GTTCCAA
3866
+ CATTTATT
3867
+ GATAAGG
3868
+ AATTTCAT
3869
+ CTTTTTGGT
3870
+ CGGTTAT
3871
+ AAAACAAT
3872
+ GAATTCAA
3873
+ CCCTCGG
3874
+ AGATAGT
3875
+ GGCCGTGT
3876
+ GACATTGT
3877
+ CACGGGT
3878
+ CTTCCGT
3879
+ CTAACCT
3880
+ GCTCTCC
3881
+ AGCCTCGG
3882
+ CAGGGAT
3883
+ AGGATCT
3884
+ CATTGCC
3885
+ AATCGG
3886
+ GGTCAG
3887
+ ATTTCAC
3888
+ AACAATTT
3889
+ CGAATCC
3890
+ AGGCTGG
3891
+ CTATACT
3892
+ CCAAGCAA
3893
+ GACGCCT
3894
+ GCATGGTT
3895
+ AATACAA
3896
+ CAATTTAA
3897
+ GGACGGTCC
3898
+ ATTTGCTT
3899
+ CGCGAG
3900
+ GCTCGCC
3901
+ GTTTCAG
3902
+ CACTAGT
3903
+ GCTGAGT
3904
+ GTTGAGGT
3905
+ ACTCGAT
3906
+ AGCGCAT
3907
+ CAGGCGG
3908
+ ATTATCAT
3909
+ AATAGAA
3910
+ AGACCCC
3911
+ ATTTGGGT
3912
+ GCATAAAA
3913
+ AATATCT
3914
+ GAATTATT
3915
+ ACCAGAA
3916
+ GCTAATT
3917
+ GATCGAT
3918
+ AAACACT
3919
+ ATGTGGT
3920
+ GGGGGTT
3921
+ ATTTTCGG
3922
+ AGACTCAT
3923
+ ATTTCGT
3924
+ GCAGTAA
3925
+ AGGCAG
3926
+ ATCCCAA
3927
+ ACCCCAA
3928
+ GCAAGGT
3929
+ CGAGCAT
3930
+ AGAGTCC
3931
+ AGCTTTTT
3932
+ GCATACAA
3933
+ GCCTGAT
3934
+ AATTCAAT
3935
+ CAGTTCC
3936
+ AATAAGT
3937
+ GATTTGAA
3938
+ GGATACT
3939
+ AGGTTCC
3940
+ CGCCCGAGG
3941
+ GCTCACC
3942
+ CCTGCAAAA
3943
+ ACAACTTT
3944
+ AAAGAAAT
3945
+ CGGAGCT
3946
+ ATTATGAA
3947
+ GCTCTAT
3948
+ CAAATGAT
3949
+ GCGCCCT
3950
+ GTTCAG
3951
+ ACGAGAT
3952
+ GGAAAGAA
3953
+ GCACCGG
3954
+ AAAAAAAAAA
3955
+ CGGGTGT
3956
+ CGCTCGT
3957
+ GGTTCGT
3958
+ ACTAGAA
3959
+ AAAAATCT
3960
+ GCAACCCT
3961
+ AGTTGATT
3962
+ CCCAAGG
3963
+ GACCATGT
3964
+ CTCTCTCAA
3965
+ ATTGTGT
3966
+ GAATTTGG
3967
+ GAGTAGG
3968
+ ACTCCTT
3969
+ ATAAACC
3970
+ AATTGAG
3971
+ GTTTGTAT
3972
+ GCTAGAA
3973
+ ACTTTATT
3974
+ ATTTGAG
3975
+ CGGAGCC
3976
+ TTTTTTAA
3977
+ AATCTCC
3978
+ ATTTCCTT
3979
+ ACACAAAT
3980
+ AGATCGG
3981
+ GCACGAA
3982
+ CTTGGGT
3983
+ ACATGAAT
3984
+ GCAAATAT
3985
+ AGATTTGT
3986
+ ACATCCT
3987
+ AATTGAAT
3988
+ GATTTCTT
3989
+ GAGGCCT
3990
+ ACCAATTT
3991
+ CATGAG
3992
+ AAAAGAAT
3993
+ AAAACTTT
3994
+ GCGGGAA
3995
+ ACCTAGG
3996
+ ATTTTCTTT
3997
+ GAGTACT
3998
+ GTTGTAT
3999
+ CCATGAGG
4000
+ GATTATAT
4001
+ AGTGCCT
4002
+ AAATTTTTT
4003
+ GTTACTT
4004
+ AGCGAAT
4005
+ GGTCTAT
4006
+ GCTACTT
4007
+ CGTGTTT
4008
+ CGAGACT
4009
+ ACAAAATTT
4010
+ AAAAAGAT
4011
+ AGTCGTT
4012
+ GAGGAGAA
4013
+ CGAAAGG
4014
+ AACCCGG
4015
+ AAATACTT
4016
+ GGTCAAT
4017
+ GGGTGCC
4018
+ GGTGGGG
4019
+ AGTAGCT
4020
+ GATGTCT
4021
+ ATTCTAT
4022
+ GTTAGTT
4023
+ CAAAGAT
4024
+ GGTAGAA
4025
+ CAACCTT
4026
+ AATTATTTT
4027
+ CGTCAG
4028
+ GTGGCTT
4029
+ GACCTAA
4030
+ GATAGAA
4031
+ AGGAGCC
4032
+ AATGGAA
4033
+ GAAAGTT
4034
+ AATAAATTT
4035
+ CCACACC
4036
+ AATCTAT
4037
+ CTCTGCC
4038
+ GCGCTTT
4039
+ ATGTACT
4040
+ GGAGCAT
4041
+ CGGTTCT
4042
+ CAGGCTT
4043
+ AAAAGATT
4044
+ ATTCAC
4045
+ AGGATGG
4046
+ GGATGATT
4047
+ CGCTGCC
4048
+ GCTAGAT
4049
+ AAAAAAGG
4050
+ ATATGCAT
4051
+ AGGTACT
4052
+ GGCCGAGG
4053
+ CGCTTGT
4054
+ CGGCCTT
4055
+ CAAGCTT
4056
+ GCAACAAT
4057
+ ATTGCAT
4058
+ AATTAAAAT
4059
+ CGGCCGG
4060
+ AATATGTT
4061
+ GGGTCGGGCGG
4062
+ CGGTTGT
4063
+ GCAGGGT
4064
+ CCTCCTCC
4065
+ CACGCCT
4066
+ GGTATAA
4067
+ AAGAAAAT
4068
+ AATTATGT
4069
+ CATAACT
4070
+ CCATGCAT
4071
+ GGTCTCC
4072
+ CAGATTTT
4073
+ CGTGATT
4074
+ GCAGTCC
4075
+ AAAACATT
4076
+ ACAAGTTT
4077
+ CGACTTTT
4078
+ ATTTGCC
4079
+ CACGCGG
4080
+ CGGTTCC
4081
+ CAACATT
4082
+ GCGATGT
4083
+ CCTTGGTT
4084
+ CATGGAA
4085
+ AGCCTGT
4086
+ AAATATTTT
4087
+ GACGGAGG
4088
+ CTTTTGTTT
4089
+ AAATTATT
4090
+ CGGCTTT
4091
+ AATTTTGG
4092
+ GAAAAATAT
4093
+ GTGGACC
4094
+ CTTCTGG
4095
+ CGGTGTT
4096
+ CGCTGCT
4097
+ CCTCGAA
4098
+ CGATCAT
4099
+ GCCGCCGCC
4100
+ GAGGTTTT
4101
+ GGTATGG
4102
+ CAGCCGT
4103
+ AATTAGAA
4104
+ GATTCATT
4105
+ CACCAAGG
4106
+ GATTGAAT
4107
+ CGCATGT
4108
+ CGTGGCC
4109
+ AGTGGCT
4110
+ CGTCCCC
4111
+ CTTGTAA
4112
+ GAACTTT
4113
+ AGCCTGG
4114
+ AGAAAAGT
4115
+ GCAGCCT
4116
+ CGCCCAT
4117
+ ATTATGTT
4118
+ AATCAC
4119
+ GGAACCT
4120
+ ATTATGAT
4121
+ AGTCTAT
4122
+ AATAACT
4123
+ GAAATCAT
4124
+ GGAGCTCT
4125
+ ACTACAT
4126
+ CAAAAGT
4127
+ CGACGAT
4128
+ GCGATCT
4129
+ GAACCAT
4130
+ ACAACAC
4131
+ AAAAATTTT
4132
+ AAAAACTT
4133
+ AGCGATT
4134
+ AAAAATATT
4135
+ CGCGCGT
4136
+ ATTTCTTTT
4137
+ AGGGGAT
4138
+ AGCCCCT
4139
+ CGCTTCC
4140
+ GAGACCT
4141
+ AGATGCTT
4142
+ ATTTACTT
4143
+ CTCTCCCT
4144
+ ATATATTTT
4145
+ CGTGAC
4146
+ GTTCCAT
4147
+ AGCCCTT
4148
+ ACAGGGG
4149
+ GCAGAAAA
4150
+ AATCACT
4151
+ GGTGCCT
4152
+ ATCCCGT
4153
+ ACTATGT
4154
+ AGTAAATT
4155
+ CTTTTTTTTT
4156
+ ACAAGATT
4157
+ CATATATT
4158
+ CAATGAAT
4159
+ ACTCACT
4160
+ ACAACATT
4161
+ AAAAGTTT
4162
+ CGAAGGCT
4163
+ AGAGCCT
4164
+ CCTCCGG
4165
+ AGCGGCC
4166
+ GCTGAGG
4167
+ GTTCAC
4168
+ AATAGTT
4169
+ ATATGCTT
4170
+ GTGGTTTT
4171
+ GGGTGAAT
4172
+ AATATCAA
4173
+ CCCCTTTT
4174
+ CTTGTGAA
4175
+ CACTTCAA
4176
+ ACAAAACT
4177
+ CTTTAGG
4178
+ ATTTCAG
4179
+ GACCTGT
4180
+ GAAATCTT
4181
+ CGTGTGT
4182
+ CCTCTGGTCGAT
4183
+ AGGCTCT
4184
+ CAGTGCT
4185
+ CGAGTCT
4186
+ AATGGTT
4187
+ CATGTAA
4188
+ ATTGGGT
4189
+ GCTCCACT
4190
+ CATGTGT
4191
+ GTTGCCT
4192
+ AAAAATCC
4193
+ CCAAGATT
4194
+ AAAAAGTT
4195
+ CTCCAAAT
4196
+ ATTTTTCTT
4197
+ CCATCTTT
4198
+ CCAACGT
4199
+ ACTTCCTT
4200
+ ACTATCT
4201
+ GCCAAAG
4202
+ ACTCTAT
4203
+ CGAATAA
4204
+ CGCGCCT
4205
+ CAGCTGT
4206
+ CAATATAT
4207
+ GATTGATT
4208
+ GGATACC
4209
+ AATTACC
4210
+ CTAAGCT
4211
+ GGAGGAGG
4212
+ ACCTCGT
4213
+ CGAGTGT
4214
+ CGAACCT
4215
+ CTCTTCTT
4216
+ CCCAACT
4217
+ CTCTGGT
4218
+ GTGGCGG
4219
+ CATTAGG
4220
+ GCGAAAT
4221
+ AAAAAATTT
4222
+ GATAAGT
4223
+ AGATAGG
4224
+ CCATGTTT
4225
+ AACCATT
4226
+ GACGTCC
4227
+ ATAAACTT
4228
+ CACACAAT
4229
+ CATATCTT
4230
+ GGTTGCTT
4231
+ CAAAAGTT
4232
+ CACGTGT
4233
+ AGTAAGG
4234
+ ACTAATTT
4235
+ CAGCGAA
4236
+ GCATGAAT
4237
+ GAAAAGTT
4238
+ GGGTCAT
4239
+ GACCAAAA
4240
+ CCTCTGT
4241
+ GATGATTT
4242
+ AAAATAAAAT
4243
+ GAGCGAA
4244
+ AGTGGCC
4245
+ CCAAAGAA
4246
+ CAGCCGG
4247
+ ATTGTTTT
4248
+ AAATAATTT
4249
+ GAGTACAA
4250
+ ACACACAA
4251
+ CAATATTT
4252
+ GCACCCT
4253
+ CTCTAAGG
4254
+ ATATGAGT
4255
+ ATATACAT
4256
+ CAAAAGAT
4257
+ GAAAATCT
4258
+ GACTAGG
4259
+ CAGCGCT
4260
+ ACCCACC
4261
+ GCACTTTT
4262
+ AAAATTCC
4263
+ ATATAGG
4264
+ ACACATTT
4265
+ GGAGAAAT
4266
+ CATTTGAA
4267
+ AGTTGTTT
4268
+ GATTATTT
4269
+ ACACCCT
4270
+ CTTGTAT
4271
+ GATACAT
4272
+ GCACCGT
4273
+ ATTTATAGCC
4274
+ CACCGAA
4275
+ CAAGAG
4276
+ CGCAACC
4277
+ CACGTCC
4278
+ GTTCTCC
4279
+ AAGAACT
4280
+ AGGGAAT
4281
+ ACAAGAG
4282
+ CAAAAACC
4283
+ CTATCCT
4284
+ GGTCACT
4285
+ GTTTTTTTTT
4286
+ ACAGTGT
4287
+ GAGGGAGG
4288
+ GCGCCGCC
4289
+ AGAAGCAA
4290
+ GCTTCGCC
4291
+ AAATTCC
4292
+ GTTGAGT
4293
+ GTTGGCT
4294
+ GCAGAGT
4295
+ GTCTGAA
4296
+ GTTTCGT
4297
+ CGATGCC
4298
+ GATCCAT
4299
+ CAACAC
4300
+ CTTGTACT
4301
+ CCAACGGT
4302
+ AATACAT
4303
+ AATTCGT
4304
+ GTAAATTT
4305
+ AGCTGCC
4306
+ ACTGGTT
4307
+ CCAAACCT
4308
+ AGGGAATT
4309
+ AAAAAGAAAA
4310
+ GCAAAAGT
4311
+ ATTTTGTTT
4312
+ AGTTTTAA
4313
+ GATACTT
4314
+ AGATAGAT
4315
+ CGATCGG
4316
+ ACTGATT
4317
+ ATTCTAA
4318
+ GTTGTTTT
4319
+ AATTCTTT
4320
+ CATGGTT
4321
+ CGAGATGT
4322
+ AGGCGC
4323
+ GCTGATT
4324
+ ACTCAC
4325
+ GCTGCAT
4326
+ ATTGTAT
4327
+ GACTAAAT
4328
+ CAGGAAT
4329
+ ATTAAGT
4330
+ CTTTGGTT
4331
+ GCTTTTCT
4332
+ GGTAATCGATT
4333
+ AGTTTTGT
4334
+ AAAATTTAA
4335
+ CCAAACAA
4336
+ AGGGTAT
4337
+ ACCCTCC
4338
+ GCGAACT
4339
+ GGAGTTTT
4340
+ AGTCTCC
4341
+ GTAAGTT
4342
+ AGAAATGT
4343
+ AATTGTTT
4344
+ CATCTCT
4345
+ CTGGCAA
4346
+ GCTGGAT
4347
+ AGCGACC
4348
+ CGGCGCT
4349
+ AGCACGT
4350
+ ACGTCAA
4351
+ GGTGGAGG
4352
+ AGCCGAT
4353
+ GGGGCCT
4354
+ GAAGAGT
4355
+ CGTCGCT
4356
+ CAACCACC
4357
+ ATTTATAGG
4358
+ GGTAACT
4359
+ GGGGTTTT
4360
+ CCTAGGT
4361
+ AGTAAAG
4362
+ GCGCTCT
4363
+ ATAAACAT
4364
+ AGAAGGAA
4365
+ CGACTGT
4366
+ CCCTAAT
4367
+ CATACTT
4368
+ CACCAAGT
4369
+ GGTACAA
4370
+ ACGACGT
4371
+ GTGGGTT
4372
+ GAGGCAG
4373
+ GATCTCT
4374
+ CATATTTT
4375
+ GCTGGTT
4376
+ CAGTACT
4377
+ AATATAAAA
4378
+ ACACAAGT
4379
+ CGTTTGG
4380
+ AGATGAAT
4381
+ CCTGCAA
4382
+ CCTTCGC
4383
+ GACGACT
4384
+ GTTGTCT
4385
+ AGAATCAA
4386
+ CGAGTGG
4387
+ GCATGATT
4388
+ CGACTCT
4389
+ ATATATATATAT
4390
+ CCATCCCC
4391
+ ACGTGCC
4392
+ GCATATGT
4393
+ CCACTTTT
4394
+ CTTTCATT
4395
+ CGCCGCT
4396
+ GCCTGAA
4397
+ ATGTGCC
4398
+ GATGTCGT
4399
+ GATATCT
4400
+ GGTGTCT
4401
+ GGAGACC
4402
+ GATCGAA
4403
+ GCGGTTT
4404
+ AGGACAT
4405
+ CCTGAAT
4406
+ ATTCCTT
4407
+ GGTGTCC
4408
+ AAATACAT
4409
+ TTTTTTCT
4410
+ GAAAACTT
4411
+ GGAGAGT
4412
+ ACTAAGG
4413
+ CTTTCAACC
4414
+ ATTTTTAAT
4415
+ ATTTTTTAA
4416
+ ACTAACC
4417
+ GATTTCAA
4418
+ AGGAGCAA
4419
+ GACAAAC
4420
+ GTTATCC
4421
+ ACCCCCT
4422
+ ACTGCAA
4423
+ CATATCT
4424
+ GAACAC
4425
+ GCATGTAT
4426
+ GCACAAAA
4427
+ AGCCAAAA
4428
+ TTTTTTGT
4429
+ GCAGTTTT
4430
+ GCGTGCT
4431
+ CCATCGG
4432
+ GACGGCGG
4433
+ ATGGCTT
4434
+ AATAATAAT
4435
+ AGGTACC
4436
+ GGTGACT
4437
+ AAATTGG
4438
+ GTGTAGT
4439
+ ATGTGTTT
4440
+ CGTGTCT
4441
+ CGTTCAA
4442
+ CGACGAGG
4443
+ GCACCGGACT
4444
+ CTGGATT
4445
+ GACGCGG
4446
+ GTGTGCTT
4447
+ CAGCAAGG
4448
+ AGATTGG
4449
+ GCTATAA
4450
+ CGGGTAA
4451
+ CGACATT
4452
+ GCTTTTGT
4453
+ CTTGCAT
4454
+ GCATTTCT
4455
+ AATATGAT
4456
+ CGTCCTT
4457
+ CGCACTT
4458
+ GGTCACC
4459
+ AAGAAGG
4460
+ GGCCGCT
4461
+ GAAAAGAAAA
4462
+ GCCTGCC
4463
+ CAAGTCAA
4464
+ CGAAAAAT
4465
+ ACACTGT
4466
+ AGTGGGT
4467
+ GGAACGG
4468
+ ACCCTAT
4469
+ ACCTTCAT
4470
+ GAGCGCC
4471
+ ACGAACT
4472
+ CGCTTCT
4473
+ CGCACGT
4474
+ CGCACGG
4475
+ CGCCGTCTTCC
4476
+ GAAATCT
4477
+ ACAGTCT
4478
+ AAAAAAGT
4479
+ CATCTAA
4480
+ ACACTTGT
4481
+ ACTGCAT
4482
+ CAGCCAC
4483
+ AGCCAAAT
4484
+ GCCTATAAAT
4485
+ CGGACTT
4486
+ AGACTGT
4487
+ CGGGTTT
4488
+ ACTTTCTT
4489
+ CAATAATT
4490
+ ATTATTTTTT
4491
+ GACGGGT
4492
+ CCTTAC
4493
+ GAGTGCC
4494
+ GTTATCT
4495
+ CTTTGCTT
4496
+ GGTGAAGAA
4497
+ GATAGTT
4498
+ CTTCTAT
4499
+ GGTATGAAT
4500
+ GGACACC
4501
+ GGCCGAACC
4502
+ ATTTACAT
4503
+ CTTTTAAT
4504
+ ATTAAATAT
4505
+ GACGAAGG
4506
+ CACTAGG
4507
+ CCAAGAGG
4508
+ GATGGCC
4509
+ AGAGATAT
4510
+ ATTTATCAT
4511
+ GATTGTTT
4512
+ CCAAGTCC
4513
+ ACTCCCTCC
4514
+ CTTTAAAT
4515
+ CCATCTCC
4516
+ GCTAAGG
4517
+ ACTGAAT
4518
+ CGATAAT
4519
+ ATTTAGAA
4520
+ GGATAGT
4521
+ GGGGAGAA
4522
+ CGATGTT
4523
+ CACGTGG
4524
+ ACTTTTGT
4525
+ GAGTACC
4526
+ CCTATAT
4527
+ AACCCTT
4528
+ CGGTTGG
4529
+ CACGGCT
4530
+ GATGTAAT
4531
+ GTCTGGT
4532
+ ATTGGCT
4533
+ ATAAAGG
4534
+ CATTGTTT
4535
+ GCCCGCC
4536
+ ATTTTTCAA
4537
+ CCATCCAT
4538
+ CATTTTCC
4539
+ CAATTATT
4540
+ GAGTTCAT
4541
+ AGACAAAA
4542
+ CGAATTTT
4543
+ ACACAGG
4544
+ AGATAAAT
4545
+ AGGTCCT
4546
+ CGGGATT
4547
+ ACAGAAAT
4548
+ GTCCTTTT
4549
+ CTTTGAG
4550
+ CGCTTGG
4551
+ ACATTATT
4552
+ ATCCAAT
4553
+ CGCCTGG
4554
+ GAATATGT
4555
+ AGTTTTTTT
4556
+ CGGAAGACGG
4557
+ CAATGCC
4558
+ AGCGGGT
4559
+ CCGGCGG
4560
+ ATTATCTT
4561
+ AATTTTTAT
4562
+ GACGGTT
4563
+ GTTTTAAT
4564
+ GACCAAAT
4565
+ CGCCTAA
4566
+ AGACCCT
4567
+ AGACAGT
4568
+ GTGTGAC
4569
+ CGCACCT
4570
+ ATGGGAT
4571
+ GCATATTT
4572
+ CCATAGG
4573
+ CGCCTTTT
4574
+ AGAAAATTT
4575
+ CATGTGG
4576
+ AGTTTCAA
4577
+ AACTACT
4578
+ CTCCCTCT
4579
+ GCTTCAC
4580
+ ACACTCC
4581
+ ACCCACT
4582
+ GACCCTT
4583
+ ACGAGAA
4584
+ ACCGAGGTT
4585
+ GTGTAGG
4586
+ AAAATGAA
4587
+ GCTCTCAA
4588
+ GTCCGGTGCACC
4589
+ ACTTGGTT
4590
+ ACAATAAT
4591
+ AGTTGAGT
4592
+ ATGGCAA
4593
+ AAAAATCAA
4594
+ CTGGCTT
4595
+ ACGGTGG
4596
+ ACTCACC
4597
+ GGAAATTT
4598
+ AGAGAGAT
4599
+ CACACGT
4600
+ GCCCACT
4601
+ ACAAAAGT
4602
+ ATTGTAAT
4603
+ ACTTTCAA
4604
+ GTTACAT
4605
+ AGATTTAA
4606
+ AGCATTAT
4607
+ AGATTCC
4608
+ CACCTTCT
4609
+ CGGCTCC
4610
+ GCAAGATT
4611
+ CCTATGT
4612
+ ACTTATTT
4613
+ CGCCTAT
4614
+ GAGTACAT
4615
+ AAACACAT
4616
+ CGCCTGT
4617
+ AATTACAT
4618
+ CGTTGTT
4619
+ CCTTCTTT
4620
+ CGTCGACC
4621
+ GATATATT
4622
+ GCTCGAT
4623
+ AGAAAGAT
4624
+ CGCAGCT
4625
+ AGAAGAAT
4626
+ CATCTCC
4627
+ GTTTAAAT
4628
+ CGGGAGG
4629
+ GGATGCC
4630
+ GCTCGAA
4631
+ CCAAGAGCAT
4632
+ ATTTACAA
4633
+ AGGACAA
4634
+ AGCGTTT
4635
+ GCACTTGT
4636
+ GCGTGCC
4637
+ CTCTAGT
4638
+ CAGGAAAA
4639
+ ACATATAA
4640
+ GGTCGCC
4641
+ ACCAGCT
4642
+ ATTTTATAT
4643
+ CTTGTCAA
4644
+ GTCCGGTGG
4645
+ ACCAGAT
4646
+ GCAGTAGGGG
4647
+ CCATCGT
4648
+ GATTTGTTTT
4649
+ ACTGCTT
4650
+ CCTACGT
4651
+ ATTTTGATT
4652
+ ATTAACAT
4653
+ ACTAGCT
4654
+ ACATTTTTT
4655
+ GACACGG
4656
+ CAATGTTT
4657
+ GACTGAT
4658
+ GGCCATGT
4659
+ AGTGAGG
4660
+ ACCTTCTT
4661
+ ACTTCATT
4662
+ GCTGGCT
4663
+ AGGTAGG
4664
+ AGTTAGG
4665
+ AGTAATTT
4666
+ CGATTGT
4667
+ GACCGAA
4668
+ CCTGAG
4669
+ GCGCGCGG
4670
+ GCTACAT
4671
+ GGAAGCTT
4672
+ CCCCCTCT
4673
+ GGAGACT
4674
+ CCTCTAT
4675
+ GCTGCCT
4676
+ AAATTCAA
4677
+ ATTATATTT
4678
+ GTGGAGATT
4679
+ ACGACGG
4680
+ AATATCTT
4681
+ CTTATACT
4682
+ GACTTGTT
4683
+ GTCTATT
4684
+ GCGCCGG
4685
+ ACAACAG
4686
+ AAAATAAAT
4687
+ ACCTGGT
4688
+ CATATCC
4689
+ CCATCCAA
4690
+ CAATCCAA
4691
+ AGCGTGT
4692
+ GCAAAGTT
4693
+ CCTAGAT
4694
+ ACTCGAA
4695
+ CTGGGCC
4696
+ GCATTTGT
4697
+ ATATATATT
4698
+ CGACTAA
4699
+ ACATTGTT
4700
+ GATTGGTT
4701
+ AAATTAAT
4702
+ CGTGTGG
4703
+ GAAGTGT
4704
+ CGCATCT
4705
+ GGTCTACT
4706
+ GAGGTATCC
4707
+ CATTTGTT
4708
+ AATAAATAT
4709
+ CAATATAA
4710
+ ATTTATTTTT
4711
+ CGCAGAA
4712
+ ACGCCAT
4713
+ GATTTTGG
4714
+ GCCCGAGG
4715
+ ATTTATCT
4716
+ ACAATTTTT
4717
+ ATTTCCAA
4718
+ CACCTGG
4719
+ ACGAGCT
4720
+ AGATAATT
4721
+ ATTTCTCT
4722
+ GAAATGAT
4723
+ GACCGTTT
4724
+ GCATGCAA
4725
+ CGTTTTTT
4726
+ CGTGGAA
4727
+ GCTTAGG
4728
+ GGTCGGT
4729
+ GCTTTTAA
4730
+ ACCCTGT
4731
+ GGTGTAT
4732
+ AGTATTTT
4733
+ GTCTAAT
4734
+ AAAATTAAT
4735
+ ACAGCCT
4736
+ GTCTGTT
4737
+ ATTTGAATT
4738
+ GTTTGTGT
4739
+ GGCTATGT
4740
+ GCTATCT
4741
+ CAAATAAAA
4742
+ AACTAGTTT
4743
+ GAAAGCT
4744
+ CTTATTTT
4745
+ GCTTGATT
4746
+ GACCTGG
4747
+ CACATCAA
4748
+ GAACATT
4749
+ GCGTGTT
4750
+ GCCCCAA
4751
+ AATTAAGT
4752
+ GCATCAC
4753
+ GGGGACTT
4754
+ GATATCTTT
4755
+ AGGTAAAT
4756
+ GACTGCT
4757
+ GGTAGAT
4758
+ ACCTAAAA
4759
+ AGACCGT
4760
+ CGTCTTT
4761
+ GAAAATCC
4762
+ CCGGGCT
4763
+ ATTAACT
4764
+ GTTTGGAA
4765
+ GATTTCAT
4766
+ CCTATGG
4767
+ CAGCGGT
4768
+ GCCATTTT
4769
+ AAAGCAAT
4770
+ AATGTAA
4771
+ GCCCTCT
4772
+ ACCGAGT
4773
+ GCCTCTCC
4774
+ GATCCCT
4775
+ CAATCGG
4776
+ AAATACAA
4777
+ CGCAACT
4778
+ ACAGGCT
4779
+ CCATAGT
4780
+ GATTCTTT
4781
+ GGGTCGT
4782
+ AAGGCAA
4783
+ ACCAGTT
4784
+ GCAAATGT
4785
+ AGCAATTAA
4786
+ GGTATCT
4787
+ GCGTCGCC
4788
+ CATATGAA
4789
+ ACTTCGG
4790
+ CCTTCTCT
4791
+ CGCACAT
4792
+ GTATCCT
4793
+ GCAAATAA
4794
+ GCTTCATT
4795
+ GCAGCAGG
4796
+ CTCCAAAA
4797
+ CGCGTCC
4798
+ CTCATCAA
4799
+ AGTTTCAT
4800
+ ACGCCTT
4801
+ GAATTCAT
4802
+ GCGTTGG
4803
+ GAAATGTT
4804
+ GTTTATGT
4805
+ AGACTCC
4806
+ GCGTTGT
4807
+ AAATCATT
4808
+ GATTAAAA
4809
+ ACGGCAA
4810
+ ACAGGGT
4811
+ GAATTAATT
4812
+ ACCATCAA
4813
+ ACTTATGT
4814
+ ACATTAAT
4815
+ GCTAAGACC
4816
+ GCAACAC
4817
+ GCTGAAT
4818
+ GTTTGGAT
4819
+ ATTATGG
4820
+ CAAAAAGG
4821
+ GCAAAGAA
4822
+ GAATTAAT
4823
+ GTGGACT
4824
+ ACAATCAA
4825
+ GGGTAAT
4826
+ ATTTGGAA
4827
+ AATAAGTT
4828
+ GGTAGTT
4829
+ GGCTGCTT
4830
+ ACATCATT
4831
+ CCTTGATT
4832
+ AAACATAT
4833
+ CATTCATGGCT
4834
+ CGGCGAC
4835
+ GCCCTCC
4836
+ CAATCAC
4837
+ GTTTGAC
4838
+ AACCTTTT
4839
+ GCTAGTT
4840
+ CGACCGTT
4841
+ ACTAGCC
4842
+ AGTTTGTT
4843
+ GCCTAGCT
4844
+ GCATAGT
4845
+ GCTAACT
4846
+ GATAGAT
4847
+ ACCGAC
4848
+ ACTTAACT
4849
+ ACTGTCC
4850
+ CCTGGCC
4851
+ AGTCGCC
4852
+ ACCGAG
4853
+ GCTGTGT
4854
+ CCTTGGCC
4855
+ ACAATATT
4856
+ GTTGTCTT
4857
+ AAATGATT
4858
+ CGGATGT
4859
+ CGTGTCC
4860
+ GAAAATGG
4861
+ AGGGGTT
4862
+ GCGTAGT
4863
+ AACAACC
4864
+ AGAAACTT
4865
+ CTTTTCCT
4866
+ CCTTAATT
4867
+ CGAGTAA
4868
+ ATATGTGT
4869
+ CTATATTT
4870
+ CATTATAA
4871
+ GGAAACAA
4872
+ AGACTGG
4873
+ CGTATCC
4874
+ ACACAGT
4875
+ ACAAATCT
4876
+ CTAAACAA
4877
+ GACCGCC
4878
+ GATCACC
4879
+ CTGTAAT
4880
+ CATGGAT
4881
+ GAGGTTGT
4882
+ GATCGC
4883
+ CAGAGAG
4884
+ CACTTTAT
4885
+ ACTATGG
4886
+ GGAAACAT
4887
+ ATTTTTGTT
4888
+ ACTTCTTT
4889
+ AGTTTCTT
4890
+ GCTTCCTT
4891
+ GTTTTTCC
4892
+ AGACAAAT
4893
+ AGAATTAA
4894
+ GGCCCTT
4895
+ CGGTTTTT
4896
+ CGTCATT
4897
+ GATCTAT
4898
+ GGTCGTT
4899
+ GCAAAATTT
4900
+ ATTCTCT
4901
+ AATAACTT
4902
+ CCAACAAT
4903
+ ACATCTTT
4904
+ CGCGGAA
4905
+ CTAAACTT
4906
+ CTCAAAAT
4907
+ CAGGTCC
4908
+ CTGTCTT
4909
+ AACAAAAT
4910
+ ATGTCCT
4911
+ CGGAGAA
4912
+ GGTATCC
4913
+ GCAAGAAT
4914
+ AAATCTTT
4915
+ GAGTGAG
4916
+ GGCGGAT
4917
+ GACTTGAT
4918
+ CTCATGG
4919
+ ATTTTTTTAT
4920
+ CATATAAT
4921
+ GCCGCCT
4922
+ CAGGTTTT
4923
+ GGATAAAA
4924
+ CGCTGAA
4925
+ AAGAAGAA
4926
+ CGAACAT
4927
+ ACCCAG
4928
+ AGGTAAAA
4929
+ GGCCGCGG
4930
+ GCGTCGT
4931
+ CCATGAAT
4932
+ ACGATGT
4933
+ CGTTTAA
4934
+ AGTGATTT
4935
+ GCATGAC
4936
+ AAATCAG
4937
+ CTTTCTCC
4938
+ ATTCAG
4939
+ ATTTAAGT
4940
+ GGGCGCGG
4941
+ GCCTAAGT
4942
+ ATTGGAA
4943
+ GCATTCAA
4944
+ AGTAGACC
4945
+ AGAGAGAGG
4946
+ ATGTATAA
4947
+ CCTAAGT
4948
+ GAATCAC
4949
+ GCCAACGGT
4950
+ GCTGGGT
4951
+ AAATAAGT
4952
+ ACTCTTTT
4953
+ GCACCGGACAGT
4954
+ GATATGAT
4955
+ GTTAAGG
4956
+ CATCTGG
4957
+ ATTTATGG
4958
+ CTTCCTTTT
4959
+ GTTTGCTT
4960
+ ATTGCAA
4961
+ GACGAACTCC
4962
+ ACGATGG
4963
+ CCCCCTT
4964
+ GGTGGCAA
4965
+ ACCTCTCT
4966
+ GGATGAC
4967
+ GGATGAAT
4968
+ CCCTCCT
4969
+ ACATTTCT
4970
+ GTTGTGTT
4971
+ AGTACATT
4972
+ AAATGTGT
4973
+ CAGTCGG
4974
+ AAAATCAT
4975
+ ACGGTCC
4976
+ AGGTTCAA
4977
+ GTCTCCT
4978
+ GATCGTT
4979
+ GCCTTGTTCTT
4980
+ ATAAATTTT
4981
+ GAGATTGT
4982
+ GCAGACC
4983
+ GTTTGCAA
4984
+ ATGTATAT
4985
+ CGTGAGG
4986
+ GAGCCCAA
4987
+ GCATAGG
4988
+ CGCATTT
4989
+ CCATAAAA
4990
+ AAAATGAT
4991
+ GTAACCCT
4992
+ AGTTCTTT
4993
+ AATGACT
4994
+ CGTGAAT
4995
+ GCATCGG
4996
+ GACCAAGT
4997
+ ACTTTTCT
4998
+ ACCTGCC
4999
+ AAGGAAAA
5000
+ ACATGATT
5001
+ AGCTGCAA
5002
+ AGGGGCT
5003
+ GAGACACC
5004
+ CGTGCTT
5005
+ ATTTCGG
5006
+ GGATGAGG
5007
+ GCATCCAA
5008
+ CACATGAA
5009
+ CTCAACAA
5010
+ GTCCCAT
5011
+ GGAGCAG
5012
+ CATTTCTAA
5013
+ GTTTTTTTT
5014
+ AGTCGAA
5015
+ AATAGAT
5016
+ CCCTCGCC
5017
+ ATCTGAA
5018
+ GAGCAAAA
5019
+ CATTACC
5020
+ AATTAGTT
5021
+ ATTATAAAA
5022
+ CGACCCT
5023
+ GCGTCAT
5024
+ CAGTACC
5025
+ GCGGCGC
5026
+ GTTTAGTT
5027
+ ATTGTAA
5028
+ ACATGTGT
5029
+ CAGGGCC
5030
+ AGTTTGAA
5031
+ CCAAACCTT
5032
+ AGAAGGCAA
5033
+ CACGCAA
5034
+ CAATAGG
5035
+ CACCTTAT
5036
+ GCATTAAAT
5037
+ GGCCGAAT
5038
+ GAGGGACT
5039
+ ACTTTTAA
5040
+ ACATGCAA
5041
+ ACAAGAAAA
5042
+ CGTAGAT
5043
+ GAAGGCT
5044
+ CGATGACAT
5045
+ GATGGCT
5046
+ CTGTCAT
5047
+ ATAAGGT
5048
+ GATCCAAT
5049
+ CCATACT
5050
+ AGGCTCGG
5051
+ CAAATGGT
5052
+ ATCCATT
5053
+ ACCTCTTT
5054
+ GTTAAGT
5055
+ ATCCGG
5056
+ CATAACTT
5057
+ GTCCCCAA
5058
+ GTTCTCAAAT
5059
+ CATCCTTTT
5060
+ CTAAGCC
5061
+ AGTTGCC
5062
+ GGAAGAG
5063
+ AGTGTGG
5064
+ AGAGGTTT
5065
+ AATCGATT
5066
+ CAGCTCAA
5067
+ CAATCTTT
5068
+ GGGTGCT
5069
+ CCAAGCTT
5070
+ ACTCAGT
5071
+ ATTGTGAT
5072
+ GACAGAG
5073
+ AGATGCC
5074
+ GGTCGCT
5075
+ CACGGAT
5076
+ GCAATCAA
5077
+ GCTTGAGG
5078
+ ATTTCACT
5079
+ GAAGAAGAAGAA
5080
+ GCTTTCTT
5081
+ ATATAATTT
5082
+ CCGGGAT
5083
+ AGGTACCCAA
5084
+ GCCATCAA
5085
+ GTTGTCC
5086
+ GAGCTCAT
5087
+ AATATAAAT
5088
+ GACGTGT
5089
+ CGAAAAAA
5090
+ AGAGTTTTT
5091
+ GACCATTT
5092
+ AGTTTATT
5093
+ ACTCGCC
5094
+ CACCTTCC
5095
+ AGTTGCAT
5096
+ CGTCGTCC
5097
+ CTGGTTTT
5098
+ CCTGCGG
5099
+ CCATCAAT
5100
+ GGAAGGAA
5101
+ GATTTTCC
5102
+ ACATTCAT
5103
+ GAGTGCT
5104
+ GCACCTTT
5105
+ GAATTGTT
5106
+ CCATGATT
5107
+ CCTAGCC
5108
+ GATGTGCT
5109
+ AGAAAAGG
5110
+ AATGTGTT
5111
+ CTTATCAA
5112
+ GGTCTGT
5113
+ TTTAAGTT
5114
+ GAGAGCAA
5115
+ ATGGAGG
5116
+ CGATATT
5117
+ CTCTACC
5118
+ CTATCTTT
5119
+ ATATCAAT
5120
+ GACTATTT
5121
+ CTGGAGG
5122
+ GCTTACT
5123
+ AGTGTCT
5124
+ CGATTGG
5125
+ CTTGGATT
5126
+ ATCTAAT
5127
+ CCATGGAT
5128
+ GAGTTTAT
5129
+ CGAGGAGG
5130
+ GCTCTCGG
5131
+ GATTCGT
5132
+ AGGTCGG
5133
+ GCATAAACCT
5134
+ ATTTTAATTT
5135
+ ATAAGCT
5136
+ GGTACAT
5137
+ AACCACT
5138
+ GCCCGAA
5139
+ ACTTAAAT
5140
+ AATTTTCC
5141
+ GGTTGTGT
5142
+ ACGAACC
5143
+ GAAAAGAT
5144
+ GTCCAAT
5145
+ GTTGGCC
5146
+ GTTGTGCT
5147
+ CGTCAGG
5148
+ ACCAACAA
5149
+ AATTTTTAA
5150
+ AGCAACAA
5151
+ GAGCCGG
5152
+ CTATAATT
5153
+ CTTGGCT
5154
+ GGTTACT
5155
+ CTCCGAT
5156
+ ACGGGCT
5157
+ AAATAGAA
5158
+ CGGTTAA
5159
+ GCAAAGAT
5160
+ GATTTTTTTT
5161
+ GTTTCATT
5162
+ GGTTACAA
5163
+ AGCGCAA
5164
+ GGATATTAT
5165
+ AGTGTTTT
5166
+ GTTAGAA
5167
+ CGGTGCC
5168
+ ACGATAT
5169
+ ACACAATT
5170
+ GGGGGAGG
5171
+ AGGGTAA
5172
+ AAAATTCAA
5173
+ GTTTCAAT
5174
+ GCAAGTGT
5175
+ ATTTGCAT
5176
+ GCGATCC
5177
+ CGTCAAT
5178
+ GGCTGAGG
5179
+ AGGTAGT
5180
+ GAGTTCAA
5181
+ ATATCATT
5182
+ GTTTGAGT
5183
+ CGGAAAA
5184
+ GACGGAT
5185
+ ACTTGCTT
5186
+ AGCTGGT
5187
+ ACATGCTT
5188
+ CACTCCTT
5189
+ GAGCCGT
5190
+ CCATCAC
5191
+ GTTTGGTTT
5192
+ CAAAAACAA
5193
+ GCGATAT
5194
+ CCTCTAA
5195
+ GGACAGG
5196
+ ATTTTCAAT
5197
+ CAAGTAT
5198
+ GCACTGG
5199
+ GTTTGGGGT
5200
+ GAGGGTCC
5201
+ ATATACC
5202
+ CGTAAAA
5203
+ CATAAATTT
5204
+ ACACCTTT
5205
+ GCCTTCAA
5206
+ ACGACCT
5207
+ CAGCTTTT
5208
+ CCTAGTT
5209
+ CGCGCTT
5210
+ CTCCGGT
5211
+ AAGGAGAA
5212
+ CCTAGAA
5213
+ CGTGGCT
5214
+ AATAAAGT
5215
+ ACACGCC
5216
+ AAAGAGG
5217
+ GCGTGAA
5218
+ AATGTAT
5219
+ AGGTTTGG
5220
+ ACGATCT
5221
+ ACCATAATT
5222
+ CGATGGT
5223
+ AGATTCAA
5224
+ AGCAATTTT
5225
+ AAAATGTT
5226
+ CGTGTAA
5227
+ AAATGGAT
5228
+ ACCCTCAA
5229
+ GATTGCC
5230
+ AGTATGG
5231
+ CTTGTGAT
5232
+ ATATATCT
5233
+ CAGAGGTT
5234
+ AGCAATAT
5235
+ GCCTGTT
5236
+ ATTGAC
5237
+ CATCAGT
5238
+ ATTAACTT
5239
+ ACTTTTTTT
5240
+ GAATTATAGCGG
5241
+ GGTCTCT
5242
+ CGGCACT
5243
+ GAGCTTTT
5244
+ CGATTCAT
5245
+ AAAACAC
5246
+ GGCTCAAT
5247
+ GCCCCTTT
5248
+ GGTCATTT
5249
+ ACCTAGT
5250
+ CCATATTT
5251
+ GCAGACT
5252
+ ACCCTTTT
5253
+ CGCGCGCC
5254
+ AGAGTGG
5255
+ GACGTTT
5256
+ CCTATAA
5257
+ AAGGTTTT
5258
+ ACCGGGT
5259
+ GAAAAAGAT
5260
+ GGCTGTGT
5261
+ ACTTACAA
5262
+ AGAAGCTT
5263
+ ACATAGG
5264
+ CGTGGTT
5265
+ ACCCCCAA
5266
+ CACCCGG
5267
+ CCAAGTTT
5268
+ GGTGGTGG
5269
+ GTTTTTTTTTT
5270
+ GCATAAAT
5271
+ GCGAAAAT
5272
+ CCTCAGT
5273
+ ACCCGAT
5274
+ AGAGAGTT
5275
+ GCTCTAA
5276
+ GCTGGAG
5277
+ CCCTGAA
5278
+ AGTAGGT
5279
+ AATGAG
5280
+ CAGGCAT
5281
+ GCACGCC
5282
+ CAGCCCAA
5283
+ ACGGGAT
5284
+ CAGAACAA
5285
+ CTTGAGT
5286
+ GAGTCTAGTTT
5287
+ CGAAACT
5288
+ ACGTGAA
5289
+ AGCTTTAT
5290
+ CTTGTGTT
5291
+ CCATAAAT
5292
+ CGAAGCAA
5293
+ CAACCAA
5294
+ ATTTAACT
5295
+ CATTCAAT
5296
+ AGAGCAC
5297
+ AATTTGTT
5298
+ AGAAAACT
5299
+ GGGGGGT
5300
+ CTCCCTCC
5301
+ CTTCTGT
5302
+ ACCAAGAA
5303
+ GGACGGT
5304
+ CCCTCGT
5305
+ AGATGTGT
5306
+ CATAAGT
5307
+ CTATCTCT
5308
+ AATAATAT
5309
+ AAAGAGT
5310
+ CCTACAT
5311
+ ATATCTTT
5312
+ GATATTTT
5313
+ CCATGCAA
5314
+ GGCTGAC
5315
+ CGACGGCGG
5316
+ CACATAGG
5317
+ ACAAGCAA
5318
+ ATATAAGT
5319
+ GAACCTT
5320
+ AAAAAACT
5321
+ GAGGACT
5322
+ ATTATTAT
5323
+ CATATCAA
5324
+ ATTAAACT
5325
+ CCTCTGG
5326
+ CAGAAGCT
5327
+ GATGTTTT
5328
+ CATGTCAT
5329
+ GAATCTTT
5330
+ GATTCAAT
5331
+ CCATCATT
5332
+ AAAGAGAA
5333
+ ACAAAACC
5334
+ GATAATTT
5335
+ GCGTCAA
5336
+ CTCCAGG
5337
+ GTTATTTT
5338
+ AATGTGT
5339
+ CGAGTTTT
5340
+ GCTCTGT
5341
+ GTTCAGT
5342
+ GAACGG
5343
+ AGATATTT
5344
+ AGCGGAA
5345
+ GATCTAA
5346
+ CAGGTGG
5347
+ GCCGACC
5348
+ CGCTCATGGCT
5349
+ GGGTAGG
5350
+ GGGTGACGT
5351
+ CCAACACC
5352
+ CGCTTCACTT
5353
+ GGTTGAGT
5354
+ CCCTAGG
5355
+ GAGGAGGT
5356
+ CATTACTT
5357
+ CGCTGAT
5358
+ GAAGAATTT
5359
+ GAGCAGCT
5360
+ ACAGTCC
5361
+ GCTTTGTAT
5362
+ CGTCCCAA
5363
+ CACACATT
5364
+ CGGGTCC
5365
+ CGGATCT
5366
+ GCCGGCC
5367
+ GAGATCAA
5368
+ ATTTGAC
5369
+ CGGTCTT
5370
+ GAAGAAAA
5371
+ CGCCCGCC
5372
+ GAATGTTT
5373
+ GGTTGGCC
5374
+ AATAAACT
5375
+ AATTTCAA
5376
+ AGCTCATT
5377
+ AAGGGTT
5378
+ CGCACAA
5379
+ ACCATGCTCTT
5380
+ GCTTGCTT
5381
+ GAGAAAGG
5382
+ AGTGGTTT
5383
+ GATTAAGT
5384
+ GGTTGGTT
5385
+ CGTAAAT
5386
+ ATAAACAA
5387
+ GGGGAAAA
5388
+ CGTCTCT
5389
+ GAAAAAAT
5390
+ AATTACAA
5391
+ GAATAGAA
5392
+ AGACCACC
5393
+ GATGTAA
5394
+ ATATACTT
5395
+ CATACCT
5396
+ CGTGCAA
5397
+ CACGAGT
5398
+ ATTAAGTT
5399
+ ACAATTCT
5400
+ ACTTTAAT
5401
+ GAGAGAGAA
5402
+ CGTCCAT
5403
+ ATATAAATT
5404
+ GCCCGGT
5405
+ GAAGCAG
5406
+ GGTGTAA
5407
+ GCATATAA
5408
+ CTTTGCAT
5409
+ GCTGGCC
5410
+ AATCTATT
5411
+ AATTTTTGT
5412
+ CGGGGGT
5413
+ GAATATAA
5414
+ AGCCAGG
5415
+ GCCAACAT
5416
+ GATGGCGT
5417
+ GATATCAA
5418
+ AAGGAAT
5419
+ GATACAA
5420
+ CACAACAT
5421
+ GATATCTT
5422
+ AATTTTTTTTT
5423
+ AATTCCTT
5424
+ GACCAGG
5425
+ ATATAAAAT
5426
+ AATTATCT
5427
+ CATTTTCTT
5428
+ GCCAAGCC
5429
+ ACATGGAA
5430
+ GCCTCCAA
5431
+ CTTTCTCAA
5432
+ ACAATTAA
5433
+ CTGTGTT
5434
+ GCGGATT
5435
+ AGTCAGT
5436
+ CGTTCCT
5437
+ GTTAAGTT
5438
+ ACATCAAT
5439
+ GGAGAGAT
5440
+ CCACCTTT
5441
+ CTTTTTCTT
5442
+ GAGACAAT
5443
+ CACGATT
5444
+ AATTCTAT
5445
+ GAGTTTTGG
5446
+ AGAGATAA
5447
+ GTTTCCTT
5448
+ ATTGTATT
5449
+ GGAAGTGG
5450
+ GAACAAT
5451
+ CGTGCCT
5452
+ GGACAAAA
5453
+ CTTTTTTTTTT
5454
+ CTTACCT
5455
+ GAAATAAAA
5456
+ GATAAATT
5457
+ GCTAAAAT
5458
+ ATTTTATAA
5459
+ GAGAGTTT
5460
+ CGCAAGT
5461
+ CCAAGGCT
5462
+ ATATAAGG
5463
+ AATTAACT
5464
+ GATCTCC
5465
+ GGGCGTGT
5466
+ GAGCATTT
5467
+ AGGGGTCC
5468
+ GCCTTCTT
5469
+ CCCTCGGCT
5470
+ GTCCCCT
5471
+ CGGTGCT
5472
+ ACATGTAA
5473
+ CAAAATCC
5474
+ AGCAAAGG
5475
+ AGAACAC
5476
+ GTCTCGT
5477
+ CATCCCT
5478
+ GCTAACC
5479
+ CATAAAAT
5480
+ AGAATAAT
5481
+ GAACCAA
5482
+ AGGAAGTT
5483
+ GGATGGAT
5484
+ CTTGGAAT
5485
+ CATTCCAA
5486
+ AAGTCGTT
5487
+ CGCTCCT
5488
+ GCACACAA
5489
+ GGTATCAA
5490
+ ATTTTAAAAT
5491
+ ATGGGTT
5492
+ CGCAAAT
5493
+ AGTTATAT
5494
+ AGTTTTCT
5495
+ CACAAGTT
5496
+ AGAAAACC
5497
+ CCATCTCT
5498
+ AGTTAAAT
5499
+ CCTCCACC
5500
+ CAATCCTT
5501
+ GCAATTAT
5502
+ GTTTTCTTT
5503
+ GAATGCTT
5504
+ CGGCGTTT
5505
+ ATTGGAAT
5506
+ CCTGACC
5507
+ GACAATGT
5508
+ CAGTGCC
5509
+ AGTCACC
5510
+ ATTTGCAA
5511
+ GACTCGT
5512
+ ACGAAAAT
5513
+ GAGGAAGT
5514
+ AGCTTGAA
5515
+ GTAACCCC
5516
+ CAATCCACT
5517
+ CTTGTGG
5518
+ AAAAGCC
5519
+ CAGTGCAA
5520
+ CAGCGAC
5521
+ GGACGCC
5522
+ ACTCCCC
5523
+ ACCAAGTT
5524
+ ACTTTGAT
5525
+ CAATACC
5526
+ AGATCATT
5527
+ GGTAAGG
5528
+ GTTTATAA
5529
+ CAAAAATAT
5530
+ GCTGTCC
5531
+ AGTCCCC
5532
+ GCAGAAAT
5533
+ CTTTTATAGCC
5534
+ AGCTCGC
5535
+ GGAAGAAT
5536
+ CCTAAAAT
5537
+ AGGTTTAT
5538
+ CCTGATT
5539
+ AGAGAATT
5540
+ GAGCGAT
5541
+ AGGGACC
5542
+ AAGTAAAT
5543
+ CTCCCCCTT
5544
+ GTTTCAC
5545
+ GGGGTCGGGCGG
5546
+ CTTCAGT
5547
+ GTTCGCC
5548
+ ACCCTAGG
5549
+ GAGGAAAT
5550
+ GCCTTCTGT
5551
+ ATCTGAT
5552
+ ATCCTTTT
5553
+ AGGGAGAA
5554
+ ATTTCATTT
5555
+ GATTCGG
5556
+ CATTGGAT
5557
+ AGACGAT
5558
+ AGCGTAT
5559
+ AGAAGACT
5560
+ CAATTGAA
5561
+ GGGCGAG
5562
+ AAAAAATAT
5563
+ GATGTGAT
5564
+ AGGTGCTCT
5565
+ GTTTTTGTT
5566
+ GAAAAAGAAAA
5567
+ CGCTCAA
5568
+ ACTTTGAA
5569
+ CGCGGCT
5570
+ CAGACAC
5571
+ GGGGCAT
5572
+ CACGGAA
5573
+ CTTATGT
5574
+ CTTTGGAT
5575
+ ATTTTCATT
5576
+ ATTTTCCTT
5577
+ GACAAGCT
5578
+ AGCCATGT
5579
+ CGCAACAA
5580
+ AGCCACAA
5581
+ CGCATAA
5582
+ GAGGACCTT
5583
+ GGGGACGG
5584
+ GCCGAAGCT
5585
+ CCTACCT
5586
+ AGCCACGT
5587
+ ACTGGAA
5588
+ GGCGGAA
5589
+ GACTTTGT
5590
+ AGATCAC
5591
+ AGATTTCT
5592
+ ACTCCCT
5593
+ AGACTTGT
5594
+ AGTTAGTCC
5595
+ AGAAGATT
5596
+ AAAGAATT
5597
+ GCTTCTCAA
5598
+ CATTGCAA
5599
+ CGCGGGT
5600
+ GTGTCCT
5601
+ ACTTTAGGT
5602
+ GAAAAAGT
5603
+ GCCAAATT
5604
+ ACAACCTT
5605
+ GCTTTGTT
5606
+ ATTTATGTT
5607
+ AAGGGAA
5608
+ ACTACCT
5609
+ GCGCGCT
5610
+ ATTGGAT
5611
+ GCATCGT
5612
+ GCCTCCTT
5613
+ ACTCCTCT
5614
+ GCGTCGG
5615
+ CCAACAGT
5616
+ ACCAGGT
5617
+ CTTCTCCTT
5618
+ ACTCCTTT
5619
+ GCCAGCT
5620
+ ATTTAGAT
5621
+ GACGTCT
5622
+ GAGACGG
5623
+ GATAGCT
5624
+ AAATGTAA
5625
+ CATAACAT
5626
+ GAGTAAAA
5627
+ GCGGTGT
5628
+ CCAACCAA
5629
+ GGGGCTTGCTT
5630
+ GATATAAT
5631
+ CAAGAGG
5632
+ CAGCGAT
5633
+ CTAAACAT
5634
+ GGTGCCAT
5635
+ ACTGTAA
5636
+ AGGAAATT
5637
+ CATTCGT
5638
+ GCCCCTT
5639
+ GCCAAGAA
5640
+ CTGGAAT
5641
+ GTTGACT
5642
+ GTTTGAGG
5643
+ ATTCTATT
5644
+ GATTTTTCT
5645
+ GGGGAGT
5646
+ GGGGACC
5647
+ CCTGCAT
5648
+ ATTTTTTGT
5649
+ CACGACT
5650
+ GAGCTTCC
5651
+ ATATGGTT
5652
+ GCAAACAA
5653
+ GAGAGGAA
5654
+ GAATTAAAA
5655
+ ATCCCTT
5656
+ GGTAACAA
5657
+ CGAGCCCT
5658
+ AGGATCGG
5659
+ AAAATTATT
5660
+ CATATGCT
5661
+ CTATGCT
5662
+ AGTTCAAT
5663
+ CGAGCGT
5664
+ GTTGGCTT
5665
+ CGGTCAT
5666
+ ATTTTTTTTTT
5667
+ CCATCACC
5668
+ CGGTCGT
5669
+ GGGTAAAA
5670
+ AGTCGAC
5671
+ GATGCCT
5672
+ GACCATAT
5673
+ CACATATT
5674
+ CTTTGTAT
5675
+ ACTGAC
5676
+ AAAAGGGACC
5677
+ CAGCAAAA
5678
+ GTTCACT
5679
+ GCCAACACAA
5680
+ GATATCAT
5681
+ CCTCCGAA
5682
+ ACAAATTTT
5683
+ GAGTTTAA
5684
+ AATATAATT
5685
+ CGATGCT
5686
+ AGCCCAAT
5687
+ ATAAAGAT
5688
+ ACGGTGT
5689
+ CTCTCCTT
5690
+ AGACACC
5691
+ CACAAAAAT
5692
+ GATGGCTT
5693
+ GACTAAATT
5694
+ CATTGAAT
5695
+ CGCCATT
5696
+ AAACAGT
5697
+ GGGTGAG
5698
+ AAATAGAT
5699
+ AGTTTGAT
5700
+ CTCCACCT
5701
+ GCACTTAA
5702
+ GATAAGAT
5703
+ ACGCATT
5704
+ CAGGTCT
5705
+ ACTTAGTT
5706
+ GCAACTCT
5707
+ GCAAAGGT
5708
+ GGCGGCGG
5709
+ ATGGGAA
5710
+ ACATGTTTT
5711
+ ATGTGCT
5712
+ CCTCTTTT
5713
+ GGAAATAT
5714
+ GATGGAAT
5715
+ AAGTGCT
5716
+ CTTTCAG
5717
+ GTTATGAA
5718
+ CATAGAA
5719
+ AATTCTAA
5720
+ CTTCTCTT
5721
+ AGGACCT
5722
+ ACATTTAA
5723
+ GGTGCGCC
5724
+ GGACTTTT
5725
+ CCTGCCT
5726
+ GCGGGGAA
5727
+ ATTCCAAT
5728
+ ACTCGAC
5729
+ GACATCAA
5730
+ GGCTGGT
5731
+ CCTCGTT
5732
+ AATCTAAT
5733
+ GCCAGTT
5734
+ GCACAAAT
5735
+ ACTGTAT
5736
+ GAGCGGT
5737
+ CCGTGAA
5738
+ CCTCGCT
5739
+ ACGCCGT
5740
+ ATTGTGTT
5741
+ GACTTAAT
5742
+ GAGTTGAA
5743
+ GACAAAGG
5744
+ GGCCGCCT
5745
+ AATTACTT
5746
+ CTATAGT
5747
+ CCAAGAAT
5748
+ GCGTCGC
5749
+ GCGGCGT
5750
+ GAAGAAGAT
5751
+ ACGTGCT
5752
+ AGTTGAAT
5753
+ CATTGAGG
5754
+ CACCGAC
5755
+ CTCTTCAA
5756
+ ACGTACC
5757
+ AATAAGAT
5758
+ CAATTGAT
5759
+ AGCCTTCT
5760
+ CTTGTGGT
5761
+ CCTTACC
5762
+ CCTCTTGG
5763
+ GCATTTAA
5764
+ CCAACTCT
5765
+ ACACCCAA
5766
+ AATTTGAT
5767
+ GCCCAGG
5768
+ CCTTAAAA
5769
+ CATTTTTAT
5770
+ ATAACAAT
5771
+ CACTTGTT
5772
+ CTTAAACC
5773
+ AGTGATGAT
5774
+ AGCCAGCC
5775
+ AGGGCTT
5776
+ GCAAGGAT
5777
+ AGCTTCAT
5778
+ ACAAGTGT
5779
+ CGGGGTT
5780
+ ACATGGAT
5781
+ GGGGGAGAT
5782
+ GGCTAGT
5783
+ ACACTTAT
5784
+ GCAAATTT
5785
+ GAGAAGAGAA
5786
+ GCGCTGT
5787
+ CACACCTT
5788
+ CGTTTTCC
5789
+ CTCTCAAT
5790
+ GACATGAA
5791
+ CTTGAC
5792
+ AGAAAAAAAA
5793
+ ACCGCCT
5794
+ AGAGCAAACT
5795
+ AATTGGACT
5796
+ CAGGGGT
5797
+ GTGGCCAA
5798
+ AATCGAA
5799
+ ACGAATTT
5800
+ ACGCTTT
5801
+ GTTCTTTT
5802
+ CATTGTAA
5803
+ AATGTCAT
5804
+ AGCTACC
5805
+ AATTGGTT
5806
+ CTGTGAA
5807
+ CAAAAAGT
5808
+ CTTTATAT
5809
+ ACAAGGAA
5810
+ GCCAGAG
5811
+ CGAATGG
5812
+ CAGATGGGT
5813
+ CTAACTAA
5814
+ GTTTACC
5815
+ CCATGGCC
5816
+ AGGGTGT
5817
+ AGAATATT
5818
+ GCTCGTT
5819
+ AACCAAAA
5820
+ GAATGATT
5821
+ CGCGCAC
5822
+ CCTACTT
5823
+ ATTTTGTAT
5824
+ AGATTTGG
5825
+ GGATCGT
5826
+ AGAAAGTT
5827
+ CCTGGAA
5828
+ CGGGGCC
5829
+ ACGCCAA
5830
+ AGGGGGTT
5831
+ GAATTCTT
5832
+ GCCGTCC
5833
+ ACAATCAT
5834
+ GAATCCTT
5835
+ ATTTCCAT
5836
+ AGAACACC
5837
+ AAAGACT
5838
+ GCAAAACT
5839
+ GCGTGAT
5840
+ ACATACAA
5841
+ GCTTCAG
5842
+ ATATGTAA
5843
+ CCTCCACT
5844
+ ATTTGACT
5845
+ AAAACTTTT
5846
+ ACATGCCAT
5847
+ GAGACGT
5848
+ ACAAATCC
5849
+ AAATCGT
5850
+ AGGGTCT
5851
+ ACAACAAAAT
5852
+ GAACTAA
5853
+ CCCAATTT
5854
+ CGAACGT
5855
+ GTTATATT
5856
+ AGCTAAAA
5857
+ AGATTTTTT
5858
+ CTCGGGGGCT
5859
+ CTCTCCAA
5860
+ AGTCTCAA
5861
+ CATTGTAT
5862
+ CACTGGT
5863
+ CACATTTTT
5864
+ GGGGACT
5865
+ GCCAAAAT
5866
+ CAGAGAGG
5867
+ ACGGATACCT
5868
+ CTGTGAT
5869
+ AATTAGAT
5870
+ GTTGACC
5871
+ AAAATTGG
5872
+ AGCCGTTGG
5873
+ CTTCTTCTTCTT
5874
+ CAGTCGT
5875
+ AGGCAGG
5876
+ AAAAAAATAT
5877
+ GCAATCCAA
5878
+ CGACGGT
5879
+ GCTAAAG
5880
+ AGTTATAA
5881
+ AGTTCGT
5882
+ CTTCCACT
5883
+ GAGGACC
5884
+ GCAACAG
5885
+ CACCATGT
5886
+ GTTCGAT
5887
+ AGAGTTAT
5888
+ CGCAATT
5889
+ GCAGAAGT
5890
+ GAATGTGT
5891
+ ATTTCTCC
5892
+ AGAAGGTT
5893
+ GGGGTCGG
5894
+ GATTATAA
5895
+ GGCCCAAGG
5896
+ AAAAAAAC
5897
+ CTTATCT
5898
+ GTCCACC
5899
+ CAGAAACT
5900
+ GTTATGG
5901
+ GGAAAGAT
5902
+ CAGCGTT
5903
+ GTTGGATT
5904
+ GTAAAGT
5905
+ AGAATACC
5906
+ CCTTAGT
5907
+ GAGGGCC
5908
+ GCATCAAT
5909
+ GGAGTAGGTTT
5910
+ CGATCGAT
5911
+ CCCTGTT
5912
+ CAAATGCT
5913
+ CTTAGAT
5914
+ CCAACAC
5915
+ CCTGACT
5916
+ GCATGTCT
5917
+ ACGTTGT
5918
+ GGTTACC
5919
+ GAATTGAT
5920
+ CCATAATT
5921
+ AGAAAGAG
5922
+ AGAAAAGAA
5923
+ GAGTTTGT
5924
+ ACGATAA
5925
+ GCTATGG
5926
+ GCATGAGTT
5927
+ GCGGTAA
5928
+ CGCCGAT
5929
+ GGTGGTTGAATT
5930
+ ATTAAATTT
5931
+ ACAGCCAA
5932
+ AGTATTATT
5933
+ GAGCCCGAGT
5934
+ GAACGT
5935
+ GCTGTGG
5936
+ ACAAGTAT
5937
+ ACTGTGT
5938
+ CTTTGGCAT
5939
+ CGGAAGG
5940
+ GATGTCAA
5941
+ GACGCAT
5942
+ GACAATAT
5943
+ AGTTATTT
5944
+ CATTATGT
5945
+ ATTTTCTCT
5946
+ ACAGCGAA
5947
+ AGTACAC
5948
+ CATTAGCT
5949
+ GAGAGAAT
5950
+ AGAAGTTT
5951
+ ACAAGAAT
5952
+ CTAAGGAT
5953
+ AATTTCTT
5954
+ CGCCAAAA
5955
+ GAAAAAGTT
5956
+ AAATCGG
5957
+ CATTTGGT
5958
+ AGATATAA
5959
+ GTTCGGT
5960
+ AGTCTTTT
5961
+ CGAACAC
5962
+ ATTCTTTT
5963
+ CCCCCATTTT
5964
+ CCACAAAA
5965
+ ATTTTATGT
5966
+ CTCTTTTTT
5967
+ GGCCAAAA
5968
+ GCTCCGG
5969
+ GGTGCAC
5970
+ GTTTCTTTT
5971
+ CAGGACC
5972
+ GACGATT
5973
+ CCTGTGT
5974
+ GCAATTAA
5975
+ AGAGCGT
5976
+ CAAGCAA
5977
+ ACACATGT
5978
+ CCTCCGCC
5979
+ GAGGAGGAGG
5980
+ CATATGAT
5981
+ AAATGTAT
5982
+ AATATATTT
5983
+ CTTCTCAT
5984
+ GGAGAATT
5985
+ AGAGAAGT
5986
+ CACAAGCTT
5987
+ AACTGAA
5988
+ AAAAATTAT
5989
+ CGCCTTAGAG
5990
+ ACTTGAAT
5991
+ AGTTTAAT
5992
+ CACCGAT
5993
+ CAATTTGG
5994
+ CGTCAGT
5995
+ GGTTTTAT
5996
+ ACCAAACC
5997
+ ATTAGAA
5998
+ CACCACAA
5999
+ AGATACC
6000
+ GGCTAAAA
6001
+ CACGTTT
6002
+ CAACTTT
6003
+ GGATGAG
6004
+ ACGATCC
6005
+ CATTGGTT
6006
+ CACTCAAT
6007
+ GGTCCAT
6008
+ ACTTGTAT
6009
+ ACTTATAT
6010
+ GGGTGAGT
6011
+ ACGCACC
6012
+ ATTTCAGT
6013
+ GCGCGCCT
6014
+ GCGTTCT
6015
+ AATGTAAT
6016
+ CGTTGCT
6017
+ CTTGTAAT
6018
+ AATTGTAT
6019
+ GGCCTTTT
6020
+ AGTTTAGT
6021
+ CTTCCCT
6022
+ CAAAAGCT
6023
+ AGAGACAT
6024
+ GCTGCTGCT
6025
+ CTAAAGTT
6026
+ CGCTAGG
6027
+ AAACATTT
6028
+ CTTGACT
6029
+ AGAGCAAT
6030
+ GTCTGAT
6031
+ CTAAGTTT
6032
+ GAGAGCTT
6033
+ AGCTCAC
6034
+ CCCCACAA
6035
+ GAGGAATT
6036
+ GCTTCTCT
6037
+ ACACGCT
6038
+ AGCAGTTT
6039
+ GTCTACT
6040
+ GGTAACCCC
6041
+ AGGCGAC
6042
+ AGCACCTT
6043
+ ATTAGAT
6044
+ GACCAAAAT
6045
+ CGGCGAA
6046
+ CAAAAACTCGT
6047
+ CGGGTAT
6048
+ ACCTACTCCCC
6049
+ CGCCGAC
6050
+ ACTTTCAT
6051
+ GTTCTAT
6052
+ ATTCATTT
6053
+ CATGTGAT
6054
+ ATGTGGAT
6055
+ CATTTTGG
6056
+ GACTAGT
6057
+ GCATCATT
6058
+ AGGAAGAT
6059
+ CCTATCT
6060
+ GAGAAGAT
6061
+ GAATCGT
6062
+ AGTTACC
6063
+ GCGGGGT
6064
+ GGGGGCC
6065
+ GAACCTTTT
6066
+ AAATTCAT
6067
+ GCGTCAC
6068
+ CTTTGTGT
6069
+ CAAGATT
6070
+ AGGAACAA
6071
+ ACGAGCC
6072
+ CACTACC
6073
+ CCCTGCT
6074
+ CGTGGGT
6075
+ CTTTTTTTT
6076
+ ACTCCGT
6077
+ CCTTCAAT
6078
+ ACATCAC
6079
+ CCAAGGAA
6080
+ CGGCTAA
6081
+ ATTTTTTCT
6082
+ ACAATAAAA
6083
+ AAGTAAAA
6084
+ CCTTGCAA
6085
+ AGCACTTT
6086
+ GATATGTT
6087
+ GTTTGTTTT
6088
+ ACAATGAA
6089
+ ATTTTGTAA
6090
+ AATGTGAT
6091
+ ACTGGGT
6092
+ GTTGGGCAATT
6093
+ AGATGGAT
6094
+ ACCTCATT
6095
+ CACATCAT
6096
+ AAGGCTT
6097
+ AATAACC
6098
+ ACTAGGT
6099
+ AGCTCTTT
6100
+ GTGGGAT
6101
+ ATAAAATAT
6102
+ AGATGGTT
6103
+ CTTGTCTT
6104
+ AGAAGAAAA
6105
+ ATTATTTTT
6106
+ ACTCGC
6107
+ CATTTTCAA
6108
+ ATTGTGAA
6109
+ ATTCTGAA
6110
+ ACCCCAT
6111
+ AGAAATGG
6112
+ AGAGGCTAA
6113
+ GAGCATGT
6114
+ CGCTTAT
6115
+ GGCCAAAT
6116
+ CACTCCCTT
6117
+ GAATGCC
6118
+ CAGAGCAA
6119
+ GGGTAGAA
6120
+ CCAAGGCAGCT
6121
+ ACAATTGT
6122
+ GTTGCAAT
6123
+ AGTATCAA
6124
+ CTTAACAA
6125
+ CTATGGT
6126
+ GCACAGT
6127
+ AGGGAGT
6128
+ CCACGTTGTGG
6129
+ ACTTGGTTT
6130
+ CTCAAATT
6131
+ GCCTTCCT
6132
+ CTTTGGGT
6133
+ AGAGGCAA
6134
+ GTCTGCT
6135
+ GTTTATGG
6136
+ GCCTCATGG
6137
+ ACAAGAGG
6138
+ ACATCCAT
6139
+ ACCTCAC
6140
+ CTCCCGT
6141
+ CCTGGTT
6142
+ CGCTCGCC
6143
+ CCTCTATT
6144
+ ACACGAT
6145
+ AAGGAAAT
6146
+ ACTTCTCT
6147
+ ACAAGCAT
6148
+ CAATTAATT
6149
+ GAGAGAC
6150
+ CATCAAAA
6151
+ ACACCGT
6152
+ ACTCAGCT
6153
+ ATGTAGG
6154
+ ACAACCAA
6155
+ CAAGTGT
6156
+ ATAAAGAA
6157
+ CCTAACT
6158
+ CGTTGGT
6159
+ GCGGCGAT
6160
+ CACTTGAT
6161
+ CTTGTATT
6162
+ AATTGGAA
6163
+ CACCAACC
6164
+ AGAGAGGT
6165
+ ACTTCAAT
6166
+ CAACCAAT
6167
+ CCCCAAT
6168
+ CATGGCAT
6169
+ CTCCAGT
6170
+ CTCTCTCTT
6171
+ AATGGAAT
6172
+ ACCCAAAA
6173
+ AGCCACAT
6174
+ AGTTAGTT
6175
+ CTCTAAGT
6176
+ CGGCTCGG
6177
+ GTTAAATT
6178
+ AAAATTTAT
6179
+ CGCTCAT
6180
+ GAGTTTCT
6181
+ GAGTCCT
6182
+ GAATCAAT
6183
+ GCACATAT
6184
+ CATGGTGT
6185
+ CGCGACC
6186
+ CCTTCAC
6187
+ AAATCAC
6188
+ ATTTTTAGT
6189
+ CCCCCATT
6190
+ GCTAAATT
6191
+ GAACGAA
6192
+ CTTATAA
6193
+ CTTTCAC
6194
+ CCAAGTGAA
6195
+ ACTCCAC
6196
+ CGGGAC
6197
+ AGACATGT
6198
+ CTTCCTTT
6199
+ GAAGTGG
6200
+ CTTTTGGT
6201
+ CGCAGTT
6202
+ AATAATATT
6203
+ GGGGGGAA
6204
+ AGCTCCAA
6205
+ AAGAACC
6206
+ AGCGAGCC
6207
+ CGACAGCC
6208
+ ACATGAC
6209
+ ACACTCAA
6210
+ CCTCTGCAG
6211
+ GTCTCAC
6212
+ AGCTTCAA
6213
+ CGGCCACC
6214
+ GAGAAGCAA
6215
+ AATAAAATTTT
6216
+ GCATTATT
6217
+ GAGACTTT
6218
+ ATTCTCAT
6219
+ CACAAAGAA
6220
+ AGAGGAGG
6221
+ GACCGAGG
6222
+ AGTCAAAA
6223
+ GAAAAGCT
6224
+ ACAAAACTT
6225
+ CCCCGCC
6226
+ GGAGAGCC
6227
+ CTTTTTGG
6228
+ CAGGCCT
6229
+ CTCTATCT
6230
+ ACTGTTTT
6231
+ GAAATAAAT
6232
+ CATCATCAT
6233
+ GCCTCAG
6234
+ GAGTAATT
6235
+ CTAACTTT
6236
+ ATTTAAGG
6237
+ CTAAGTAT
6238
+ GCATTCAT
6239
+ CGAAGAAGCT
6240
+ GTAAGGT
6241
+ GCGGAAT
6242
+ GACTGGT
6243
+ ACATCGCC
6244
+ ACGCAGG
6245
+ GAGCTAAAT
6246
+ CTAAGGT
6247
+ GAGTCGG
6248
+ GAGCACAT
6249
+ GGCTCGT
6250
+ AAACAATT
6251
+ GTTTAATTT
6252
+ CACCAGT
6253
+ CACCCGT
6254
+ CGCCGAGG
6255
+ GACATCTT
6256
+ GCCGCCGCCGCC
6257
+ AGAGTTGT
6258
+ GTGTGGAT
6259
+ GTGGCCT
6260
+ CACCCCCC
6261
+ GATTCCTT
6262
+ CGAAAGAA
6263
+ AGATCAAT
6264
+ AGTTTTGG
6265
+ GAATAAAAT
6266
+ CTGTATT
6267
+ AGCCCGACC
6268
+ GCATCCGGGG
6269
+ AGGCACT
6270
+ CACCATAA
6271
+ GCCTAGT
6272
+ AATTGCTT
6273
+ GATGATCAA
6274
+ GATTTGGT
6275
+ CTCTATTT
6276
+ GATTGGAT
6277
+ AGCACCAA
6278
+ ACAACTTTT
6279
+ AGTTTGGT
6280
+ AAATGCC
6281
+ CGGACCT
6282
+ GCTGTTT
6283
+ AGATGTCT
6284
+ CCTCTCAA
6285
+ GCTTCACTT
6286
+ GCACGAT
6287
+ AGCGTCC
6288
+ CAGCAAGT
6289
+ GCAAGGCT
6290
+ ACAAAGATT
6291
+ GAGATTAT
6292
+ GCGGTGGT
6293
+ CTTCTGAA
6294
+ AATGTCTT
6295
+ GCAGCGT
6296
+ CAGTTTAT
6297
+ GTTATGTT
6298
+ CTAAATTTT
6299
+ GCACCTCC
6300
+ AATCCCAT
6301
+ AAATGGTT
6302
+ CACATAAT
6303
+ AGGAAAG
6304
+ AGCAAATTT
6305
+ GTCCAGT
6306
+ AAACACC
6307
+ GGCCGAT
6308
+ AGACAATT
6309
+ ATAAAGTT
6310
+ ATATGGAT
6311
+ ACTAACAT
6312
+ AACCCAT
6313
+ AGATGTTT
6314
+ GCCCGCT
6315
+ GTTGTGAA
6316
+ CCCTATT
6317
+ ACCTTGTT
6318
+ GAGAAAGAA
6319
+ AATTCCAA
6320
+ CATGTCAA
6321
+ ACCACACC
6322
+ CTTTATTTT
6323
+ CCATGCTT
6324
+ CTATGTTT
6325
+ CACAATAA
6326
+ GTTTTATTT
6327
+ GCGCTAT
6328
+ ACCTTCAA
6329
+ CGACTTCT
6330
+ GAACGGT
6331
+ GTCTGCC
6332
+ CGGCCGT
6333
+ GAGTTGTT
6334
+ ACAAGAC
6335
+ CGGATCC
6336
+ CGCGTGT
6337
+ GAGCCTCT
6338
+ GTTTTAAAT
6339
+ CGGCTCCTAGCT
6340
+ GAAAAACTT
6341
+ ACGTTGG
6342
+ ATCTGTT
6343
+ CAATGAC
6344
+ AATAATCC
6345
+ GAGAGAAAA
6346
+ ACCATGAA
6347
+ AGCATGAA
6348
+ ACGAAATT
6349
+ CTCTAAAA
6350
+ GGAAACTT
6351
+ AGATAGAA
6352
+ AGATATGT
6353
+ AATGTATT
6354
+ ACCCCTAATTAT
6355
+ CTAAAGAA
6356
+ GCCTCCCT
6357
+ GACCGTTGG
6358
+ GCTGTCAA
6359
+ GGTCTCGG
6360
+ AGGCCAT
6361
+ GGTGAACT
6362
+ AGACCGG
6363
+ GAAAAACC
6364
+ CACTAGAA
6365
+ CCCTTAGG
6366
+ CATCGCC
6367
+ GCAAGCAA
6368
+ CGTCGAG
6369
+ CATGTAAT
6370
+ AGTCGGT
6371
+ ATTCAGG
6372
+ GCCTTTGT
6373
+ ACCCTGAA
6374
+ AAAAATGAA
6375
+ CTTAAGT
6376
+ GCTACCT
6377
+ CACAGCAA
6378
+ ACTTAAGT
6379
+ CGGGAG
6380
+ GCAGAGCT
6381
+ CCTCTAGG
6382
+ GTTGTATT
6383
+ CTTTGTAA
6384
+ CGTCCCT
6385
+ GACTAAAA
6386
+ GACTTCAA
6387
+ GCTTGTGT
6388
+ AGTAACC
6389
+ GGACCGTCC
6390
+ GAGGACAA
6391
+ GAGTATAT
6392
+ CTTGGGCC
6393
+ AGGATCAA
6394
+ CTTTGTGG
6395
+ GTTATAAT
6396
+ ACTCTGT
6397
+ CATTTTTTTT
6398
+ GCACATGT
6399
+ GAGTTGAAGT
6400
+ CGGCCAC
6401
+ ATTCTAAT
6402
+ CAAGTACC
6403
+ AGTTGTGT
6404
+ ATTTTCTTTT
6405
+ CACAATAT
6406
+ ACTTGAG
6407
+ ATAAGTTT
6408
+ AAAAATAATT
6409
+ CGAAGGAT
6410
+ CGCGAGCT
6411
+ ATTTTTCCT
6412
+ ACAATTTAT
6413
+ GGCCAGCC
6414
+ ATATCTAT
6415
+ ATTCCTTTT
6416
+ AAATAACT
6417
+ CGAAAGT
6418
+ ATTTCAAAA
6419
+ CACTTTCT
6420
+ ACGCGCC
6421
+ GAGCAAGG
6422
+ GGGCGTCC
6423
+ GGAGAGAA
6424
+ CAGTTTCT
6425
+ ACACACCT
6426
+ GCCCGTT
6427
+ GCGCGCAA
6428
+ GGAGCACC
6429
+ ATTGTCAA
6430
+ ACAGGCC
6431
+ GCACATTTCC
6432
+ GATCACT
6433
+ AATTCTTTT
6434
+ AGGTACAT
6435
+ GCCAAAGG
6436
+ AAAAGGTT
6437
+ CGTCTCAA
6438
+ CACCTATT
6439
+ ACTGTCT
6440
+ ATAATTTAT
6441
+ CGATGAAT
6442
+ AAGAACAA
6443
+ AGGATGAA
6444
+ AGTTCCAA
6445
+ GGGCATAT
6446
+ ACCGATT
6447
+ GTTCTCCT
6448
+ GCTTCCAT
6449
+ GCAATAAT
6450
+ GACCAACT
6451
+ AAAACGG
6452
+ ATTTTATTTTT
6453
+ GGTTGGGGCTAT
6454
+ AGGGTCC
6455
+ GAGCACTT
6456
+ CTCTTCGG
6457
+ AGCATTTTT
6458
+ CCAACTTT
6459
+ CGCCCGAA
6460
+ CAGGTTAT
6461
+ ACTACTTT
6462
+ GTTGTGCC
6463
+ AGCCCCCGAGG
6464
+ ATTGGATT
6465
+ GCAACATT
6466
+ GAATTTCC
6467
+ CGCAGAT
6468
+ CCATAGAT
6469
+ GTGGCGT
6470
+ AGAGACAA
6471
+ ACGTTTTT
6472
+ CTTCCCAA
6473
+ AGAAATCT
6474
+ CAGTAGCC
6475
+ ATTGGGCATGTT
6476
+ GCATACAT
6477
+ CCCAAAAT
6478
+ CCATCGCC
6479
+ GCCCCCT
6480
+ GGTAAAAT
6481
+ CTCAAGAA
6482
+ CTTACTT
6483
+ GGTTGTTT
6484
+ CAGAGTTT
6485
+ GCGTTCC
6486
+ CATATCCT
6487
+ CAAAATCAA
6488
+ GGTGGACT
6489
+ CACCAACT
6490
+ ATTTTGAAT
6491
+ AACAAATT
6492
+ CAGCGAG
6493
+ CATTGCTT
6494
+ AGAAAGAAAA
6495
+ CTTCTCCAA
6496
+ GATTTGCTT
6497
+ CCTTCTGT
6498
+ GAGACTAA
6499
+ CATGTGTT
6500
+ CTTGTAGTTGT
6501
+ AGTATAAT
6502
+ GAAGAACT
6503
+ GTTTTGCT
6504
+ AAGGAGG
6505
+ GGGTAGT
6506
+ ATTTTAAATT
6507
+ ACGCAAT
6508
+ CCACAGG
6509
+ CGTTCGCC
6510
+ GATATGAA
6511
+ CATCTAT
6512
+ CAATGATT
6513
+ ATTTGAAAA
6514
+ AGATACAT
6515
+ CCCCACC
6516
+ GTATGCT
6517
+ CTTAGTT
6518
+ CAGGAACT
6519
+ GCATTTTTT
6520
+ GAGATATT
6521
+ CGCCGCGG
6522
+ ACTGGAT
6523
+ CAGGCAC
6524
+ CCAAGAC
6525
+ GCACTCAA
6526
+ GCCCAAGT
6527
+ GGCCACCT
6528
+ GGTTTCGC
6529
+ GGAACAC
6530
+ AAAACTAA
6531
+ CCTCAAAA
6532
+ CATCGAC
6533
+ CGAACCCCT
6534
+ AGAATTGT
6535
+ ATGTGATAAT
6536
+ CGCCGGT
6537
+ GATAAGTT
6538
+ CTTAATTT
6539
+ ACTTTGGCT
6540
+ CATCTTTT
6541
+ GCAATTTTT
6542
+ GCCTACC
6543
+ GCCCGAT
6544
+ CAGGGAC
6545
+ ACCTCTTTT
6546
+ GAATAAATT
6547
+ GCCAGGT
6548
+ CAGCCGAA
6549
+ AAGTCCAT
6550
+ CGAACATGCC
6551
+ AGAATGGT
6552
+ GGCCGTCC
6553
+ GCCGCGG
6554
+ CTTTAATTT
6555
+ GCATCGC
6556
+ ATTTATATT
6557
+ ATGTCGT
6558
+ GAGCTCGGT
6559
+ CCAAAACTCAT
6560
+ ACTTGGAA
6561
+ CAATTTCC
6562
+ GATCTGG
6563
+ CCATGAC
6564
+ GGCACC
6565
+ AATTTTAAT
6566
+ GATCAACTT
6567
+ CAACTCCT
6568
+ AGGTGATCCTGT
6569
+ ATTTTCGT
6570
+ GAATCATT
6571
+ GTCCAAAA
6572
+ CACATTCAT
6573
+ AGTTTTTTTT
6574
+ AGAAGTAT
6575
+ AAATAGTT
6576
+ GAATGGTT
6577
+ CAGAGAC
6578
+ ACTCGTT
6579
+ GAAGGCC
6580
+ AGAAGCAT
6581
+ CTTAAGG
6582
+ GTTGGCAA
6583
+ GTTGTGAT
6584
+ ACGCGGT
6585
+ CAGGGAGG
6586
+ ACTCAATT
6587
+ GTAAATAT
6588
+ ACGCAGT
6589
+ AATTCGG
6590
+ AGGCAAGT
6591
+ GGAAGGAT
6592
+ GCTTGTTT
6593
+ ATGTGATT
6594
+ ATTTTAGTT
6595
+ ACGCTAA
6596
+ CATTGCCT
6597
+ CAGTTTGT
6598
+ CGATCCT
6599
+ CGTGACC
6600
+ CGAGAGT
6601
+ CACAGAG
6602
+ CCTCCCAA
6603
+ GCGCTAA
6604
+ CAATATCT
6605
+ CAGCCTCGG
6606
+ CACACCAT
6607
+ CGCGGACT
6608
+ GCAGAGGT
6609
+ AAAAAATAA
6610
+ AGATGATT
6611
+ CACATATAT
6612
+ CTTCTATT
6613
+ CATCGAA
6614
+ CATCAATT
6615
+ GTTTCAAAT
6616
+ GGGTCTTT
6617
+ AAAGCCAT
6618
+ CTTCGCT
6619
+ GGGGGTGT
6620
+ AATCCCT
6621
+ GCCTCCGT
6622
+ CCACACAA
6623
+ CGAGAAAA
6624
+ ATTAAAGT
6625
+ ACTTTGTT
6626
+ CACCATTT
6627
+ GGAAGGAG
6628
+ GTCCATAT
6629
+ ACCAAACTT
6630
+ GGTTGGGAA
6631
+ CACCTTGT
6632
+ GTTATCTT
6633
+ GGATCCTCT
6634
+ AGGGTATT
6635
+ GCGCATT
6636
+ GAGGGAG
6637
+ ACTTACTT
6638
+ AGCAATGT
6639
+ AGTGGAAT
6640
+ AGTAGGAT
6641
+ GAGAAGCT
6642
+ GGTCTTGTT
6643
+ GCACATTT
6644
+ CTTTCCAA
6645
+ CGTAGAA
6646
+ CCTTGGGG
6647
+ ATGGGCT
6648
+ CTTTCTAA
6649
+ ACATATTTT
6650
+ CACTTCTTCTAA
6651
+ GAGATGGAT
6652
+ CATGTGAA
6653
+ CTTCGAA
6654
+ CGCGAAT
6655
+ CAGGAGGT
6656
+ CACTTAAT
6657
+ CTCTCGG
6658
+ GCTTGTGAA
6659
+ GCATACC
6660
+ GCTTTGAA
6661
+ CCTGGAT
6662
+ GTTTTGTTT
6663
+ CAGAGATT
6664
+ CGCTTAA
6665
+ ACACACTT
6666
+ CCCAAACC
6667
+ AGAGTTCT
6668
+ GAAAAACAA
6669
+ GCGCCACC
6670
+ CATGAGT
6671
+ GATTTAATT
6672
+ CACGCGT
6673
+ CTCCCGG
6674
+ GAATTGTAT
6675
+ CGGTGGCGG
6676
+ CTTTTTTAT
6677
+ GTGTGCC
6678
+ AACCGAA
6679
+ AAAAAAAAAT
6680
+ GAACCTCGGT
6681
+ CATTAAGG
6682
+ ACCTTGAA
6683
+ AGCATCAA
6684
+ AGTGAAGAA
6685
+ ATATATATGT
6686
+ AAAACCAA
6687
+ ATATAGAT
6688
+ ATGTGCTT
6689
+ GACGGAC
6690
+ CGTCCAA
6691
+ GACCCAAT
6692
+ ACTATCAA
6693
+ GTTAATTT
6694
+ AAAATTGAA
6695
+ AGGGCAA
6696
+ CCTTCATT
6697
+ GTTCTAA
6698
+ GTTGGCGG
6699
+ ACACCTCT
6700
+ ATATCCAA
6701
+ ATCTCCT
6702
+ GCAGGTTT
6703
+ GAGGGATT
6704
+ GACTACC
6705
+ CCCCACT
6706
+ GCAGCAC
6707
+ ACAGAATT
6708
+ GAGAATAA
6709
+ CTTTGTTTT
6710
+ ACCTCCTTT
6711
+ AGAGGCTCGT
6712
+ CCGTCAA
6713
+ CCATGGAA
6714
+ AGCAGCAA
6715
+ GACGGCT
6716
+ GTGGAGATTCCT
6717
+ ATGGACT
6718
+ GACACAAT
6719
+ ACACTGG
6720
+ AGAGCGG
6721
+ AAAACAAAA
6722
+ AATTAAGAA
6723
+ CAGTTGAA
6724
+ GATCTGT
6725
+ GGTTCAC
6726
+ GATGTGTT
6727
+ AATCCAAT
6728
+ GTTTGACT
6729
+ GCATAAGT
6730
+ CACTCTCT
6731
+ CTGGGTT
6732
+ CTTCGC
6733
+ GCCGATT
6734
+ CTATCTAT
6735
+ AGCTCCTT
6736
+ AAAGCCT
6737
+ ACCTCTCC
6738
+ CAGGGGTT
6739
+ AGAGCTCT
6740
+ CTTCTTAA
6741
+ CACCAAATT
6742
+ ATTATAATT
6743
+ ACAACTCT
6744
+ GCTTTGAT
6745
+ CGAGGTCT
6746
+ AATGGTTTT
6747
+ CATGTATT
6748
+ AAATGCAA
6749
+ GCAATGAA
6750
+ AGATGGAA
6751
+ CAAATGCAA
6752
+ AGTGGGG
6753
+ CACACATAT
6754
+ CGTAATT
6755
+ ACATAATTT
6756
+ CTTTATGT
6757
+ AACTGAT
6758
+ GCTCAGT
6759
+ AGAATTCT
6760
+ AGCAATAA
6761
+ GAGCTTGT
6762
+ AGCTTTGT
6763
+ TTTTTTCC
6764
+ AGACAGG
6765
+ GTTCAATT
6766
+ CGATCAC
6767
+ AGTTGGTT
6768
+ CACCATGG
6769
+ CTTTGCCGAGT
6770
+ CCTCCATT
6771
+ AGTAGCC
6772
+ ATATCAC
6773
+ CGACTTGT
6774
+ GCGAGGAT
6775
+ CCTCTCTT
6776
+ AGAACAAT
6777
+ GCTCGGT
6778
+ GATGGAG
6779
+ GCCCTAA
6780
+ GAATAAGT
6781
+ AGCTGACC
6782
+ GACAGAGG
6783
+ GCCACGG
6784
+ ATTTCCAAT
6785
+ AGGGTCAA
6786
+ GCCCCGG
6787
+ GGTGAATTTT
6788
+ GCTTGGTT
6789
+ AAATGGGT
6790
+ GCCCTCGG
6791
+ ACCTAATT
6792
+ GAGTCATT
6793
+ GGTGTTTT
6794
+ AAAAAAAG
6795
+ CTCTACTT
6796
+ GTTTCACT
6797
+ ACTTTTGG
6798
+ ACGCGAC
6799
+ GGTGGAC
6800
+ GCCGGTT
6801
+ AAACGAA
6802
+ GGAAGCAA
6803
+ ACTCTCC
6804
+ GAGGAGAT
6805
+ ACGTTAT
6806
+ AAAAGAG
6807
+ AGACACAT
6808
+ AGACATCT
6809
+ GATGATGG
6810
+ ACAAAGGT
6811
+ CTTTGACC
6812
+ AGTTGTAT
6813
+ GATTAAATT
6814
+ CAGCCTTT
6815
+ ACTTATAA
6816
+ GGTCCATT
6817
+ AGCCAAAGTCC
6818
+ CGAAGCAG
6819
+ CAGAATGT
6820
+ AATTTGAA
6821
+ AGTCAGG
6822
+ CAAATAAAT
6823
+ CTAAGGTT
6824
+ ACAGAGAA
6825
+ AGATTATT
6826
+ GTTCGTT
6827
+ AGGGTTTTT
6828
+ CAGCTTCC
6829
+ GCGGTCT
6830
+ ACCATCTT
6831
+ ACTTGTTTT
6832
+ GAATGTAT
6833
+ AAGGGAT
6834
+ GCTGCGT
6835
+ CGTGGAT
6836
+ CAAGTCAT
6837
+ GCATGTCC
6838
+ CACCACAT
6839
+ AGCACCAT
6840
+ GAGGAGTT
6841
+ CCATGACC
6842
+ CGGCAAT
6843
+ GCACAACT
6844
+ CTTATATT
6845
+ CGACTGG
6846
+ GCCCCAGCC
6847
+ AGCTAAAT
6848
+ CAAAACAAT
6849
+ ATGTACAT
6850
+ CGAGCCCC
6851
+ CCTATCC
6852
+ GGTGCGG
6853
+ GACACCAA
6854
+ GAGACATT
6855
+ GGACTGG
6856
+ AGCAAAAGT
6857
+ AAAACCCT
6858
+ AATCTCT
6859
+ AGAGATGT
6860
+ CAAAAATTT
6861
+ CACTAATT
6862
+ AGAGGGGGGT
6863
+ AGGATTTT
6864
+ ACACATAA
6865
+ GGTTCCGGTGG
6866
+ GAGAGAGT
6867
+ GATTGCCT
6868
+ AGTAAGAT
6869
+ CTTGTCC
6870
+ CCTTGGAA
6871
+ CAATTGTT
6872
+ CACGGTT
6873
+ CTAAGGAA
6874
+ GCGCAAGAGCT
6875
+ CGCCCTATT
6876
+ ATGTGTAT
6877
+ GTTTTAGT
6878
+ CAGCTTCT
6879
+ ATATATGG
6880
+ ACGTACT
6881
+ GGTGGTTT
6882
+ GCCACAC
6883
+ AAATAAAG
6884
+ GCGCGGGG
6885
+ GTTCCATT
6886
+ GACCACTAT
6887
+ ATATACAA
6888
+ ACGAAGAAAT
6889
+ AGGCTAT
6890
+ GCAAGAC
6891
+ GATTACC
6892
+ GTTTCTCT
6893
+ ACTTAGCTT
6894
+ GGAAGACGG
6895
+ AAATCTAT
6896
+ CACACTTT
6897
+ CGCCACT
6898
+ GATGATGAT
6899
+ ATGTAATT
6900
+ CCCCAGG
6901
+ GCAGCAGT
6902
+ AGATCGT
6903
+ GCACACTT
6904
+ GGATGGAA
6905
+ AGATGAAAA
6906
+ GTTGTCAT
6907
+ CTTTATCT
6908
+ CAATGTAT
6909
+ CCACAGT
6910
+ GCATTCTT
6911
+ GCCAGCC
6912
+ ACATAAGT
6913
+ GAGTCGT
6914
+ ATGTAGT
6915
+ ATTTTTGAA
6916
+ ATTCCATT
6917
+ CCGGCAA
6918
+ AGAAAATAA
6919
+ CACAACTT
6920
+ ACATACCTT
6921
+ GCATGGAA
6922
+ GACTTGAA
6923
+ CAATGGAA
6924
+ CTTAACTT
6925
+ GAGTTTGG
6926
+ AGAAATCC
6927
+ AAACACAA
6928
+ GGCTGCACC
6929
+ CGACGCT
6930
+ GGAGCGT
6931
+ NNNNNNNNNNNN
6932
+ CGTTCGTT
6933
+ CAAAACCCT
6934
+ GTTTACTT
6935
+ GCTCATTT
6936
+ GAAGGAGAA
6937
+ GGCGGGG
6938
+ GTTTCTAT
6939
+ ATATAACT
6940
+ AATATCCT
6941
+ CAGATTCT
6942
+ CTAAAGAT
6943
+ CCTTCTTCT
6944
+ GTTTGCCTCAT
6945
+ GCCCTGT
6946
+ GAGGAGCT
6947
+ AAGAAATT
6948
+ CAGAGGAA
6949
+ CTAAGCAA
6950
+ CTTTATAA
6951
+ GGGTACC
6952
+ GGTAGCC
6953
+ GCTTCTTTT
6954
+ CTAAGATT
6955
+ CGCGGTT
6956
+ CATGGCAA
6957
+ AGGGGGG
6958
+ GAGACCCT
6959
+ CCAACTCC
6960
+ GTTTGTAA
6961
+ CGAAGAC
6962
+ CGACTTGG
6963
+ AGTATATT
6964
+ GCTCCAAT
6965
+ ACTATATT
6966
+ ATGTATTT
6967
+ AAATTGAA
6968
+ CATTGACC
6969
+ CATTATCT
6970
+ GAGTGGTT
6971
+ AATTCCAT
6972
+ GTTGATTT
6973
+ ACATAGTT
6974
+ CCACGAA
6975
+ GCAGAGGTT
6976
+ GTTTATCT
6977
+ CTTTGAC
6978
+ AAAAGCAA
6979
+ ACGAAGAA
6980
+ CCCCCGGAT
6981
+ CAGGATCT
6982
+ AGGGAAAA
6983
+ GCATGCTT
6984
+ ACATTTTAT
6985
+ GCAGCCAT
6986
+ GAGTGATT
6987
+ AAAAAACAA
6988
+ ACGGTAT
6989
+ GTTAGAT
6990
+ GCCCTAT
6991
+ GCTCCTTT
6992
+ CTCCGTCC
6993
+ GTAACACT
6994
+ ACCAACTT
6995
+ GCATTCCCTT
6996
+ AGTCCTCT
6997
+ ACTTATCT
6998
+ CCCCCGG
6999
+ AGGGGCAA
7000
+ AGATTCAT
7001
+ GATACCAATT
7002
+ ACTTAGAAAT
7003
+ CAAATTCAA
7004
+ CACTTTGT
7005
+ AATCCATT
7006
+ AGCAGGAA
7007
+ CCAAAGAT
7008
+ AAAAATAAAT
7009
+ GACACTTT
7010
+ GGACAGTCT
7011
+ AATGTCAA
7012
+ AATTTTTTAT
7013
+ CACCATCT
7014
+ ATAAGAAT
7015
+ CGTACCT
7016
+ ACATGTCT
7017
+ GTTGCAC
7018
+ AGGATCC
7019
+ ACCTCCCT
7020
+ ATGTAAAT
7021
+ GCATCACT
7022
+ CGGCGGCGGCGG
7023
+ ACTATCC
7024
+ GAAAATGAA
7025
+ GATTATGG
7026
+ CGGATTT
7027
+ CAAATATTT
7028
+ AGTTGAG
7029
+ GACATCAT
7030
+ ACAAGCTT
7031
+ GGAGCAGG
7032
+ CGGGCGAGGCGG
7033
+ CGAGCTAGG
7034
+ CAGATCAA
7035
+ GAGTGTGT
7036
+ CGGTAAT
7037
+ GCCCTTTT
7038
+ GATGTCGG
7039
+ CATCCACT
7040
+ CTTATCTT
7041
+ CGGCCCT
7042
+ GGGCCGG
7043
+ GCCCATTT
7044
+ GATGAATT
7045
+ GCAGAATT
7046
+ GCCAATTT
7047
+ CATGTCT
7048
+ GCTGCGG
7049
+ GTTAACT
7050
+ ACAACCAT
7051
+ GAAGTATT
7052
+ CGCCCTCC
7053
+ GGATCTTT
7054
+ GACTTTCT
7055
+ ACGCCGCC
7056
+ ACTTGTAA
7057
+ CACCACCT
7058
+ GTTCGAG
7059
+ ACGATTTT
7060
+ CGAGGTCC
7061
+ CGGAAGTT
7062
+ AAATCCTT
7063
+ GCTATTTT
7064
+ GAATCGAA
7065
+ CGCTGAC
7066
+ CGGAATT
7067
+ GATGGATT
7068
+ GTTGGTTTT
7069
+ ATATAGTT
7070
+ CGTTGAGG
7071
+ AGAGGTGT
7072
+ ATTTCAATT
7073
+ AAAAAAACT
7074
+ CAGCATCT
7075
+ CAGGCGT
7076
+ GAATAAAG
7077
+ GCACATAA
7078
+ CAGTAAAA
7079
+ CTTATAAT
7080
+ ATGTAAAA
7081
+ AGCCAGCT
7082
+ GAGCGAGG
7083
+ ACTTGGAT
7084
+ GCAGCAAT
7085
+ ACCGACC
7086
+ GAAGCCT
7087
+ GTTATCAA
7088
+ CTTTCCAT
7089
+ GCTTGGAT
7090
+ AATTCACT
7091
+ CGTTAAT
7092
+ CAAGTGAT
7093
+ ATATGAG
7094
+ AGATGCAA
7095
+ CATTAGTT
7096
+ CACAAAGT
7097
+ GCAGAGAA
7098
+ CGGAACC
7099
+ AGAGGAGT
7100
+ GCCAACAA
7101
+ AGATGAC
7102
+ ATTATGGT
7103
+ CGCGACT
7104
+ GATAAACT
7105
+ GTTTATTTT
7106
+ CAAGATTT
7107
+ CATCTGGCT
7108
+ ACGTCAT
7109
+ GAATATCC
7110
+ GGTGGCGG
7111
+ GAGATGAT
7112
+ CTTCCGAA
7113
+ CGCCGTT
7114
+ GCAAAAGG
7115
+ GCGATTTT
7116
+ ATTGGTTTT
7117
+ AGCATTAA
7118
+ GCGGAGTT
7119
+ GACCATCT
7120
+ CAATTCCT
7121
+ GCATGTAA
7122
+ GGATGAGGCAA
7123
+ AGGTCGT
7124
+ CCTCCCCT
7125
+ CACAAGAT
7126
+ GGGCATAA
7127
+ GGCCATTT
7128
+ GTATCCCGGAGG
7129
+ CCAAGTAA
7130
+ AAAATATTT
7131
+ ACAACTGT
7132
+ AAATTCTT
7133
+ ACCACCAA
7134
+ CACTAAAT
7135
+ GGTTGCCT
7136
+ CACATTGT
7137
+ CACCATCC
7138
+ GGAAGGGT
7139
+ GTTGTCAA
7140
+ AGAAATTTT
7141
+ GCCGGGG
7142
+ ACGCTCC
7143
+ GGCCCCT
7144
+ GAGGGGCT
7145
+ AGCAAGAA
7146
+ CACCTCAA
7147
+ GATCATTT
7148
+ AAACACTT
7149
+ GCAGCGC
7150
+ AGGCTCC
7151
+ ATAACTTT
7152
+ CCAAATTTT
7153
+ GCTAGCC
7154
+ CGACCTCC
7155
+ CTTTTGATT
7156
+ AAAATATAT
7157
+ CTTCCATT
7158
+ CAGGCGC
7159
+ GAGAGGGT
7160
+ AAGTAGT
7161
+ GCTTCAAT
7162
+ ATTATTGG
7163
+ CACCCCGT
7164
+ CTCTTGCT
7165
+ ACCTTGGT
7166
+ AATTTTCAA
7167
+ AAAATTAAAA
7168
+ GGAGAGGT
7169
+ CTTTTATTT
7170
+ CACGTAT
7171
+ GTTCTGT
7172
+ ATAACCT
7173
+ ACCTATTT
7174
+ CATCCCC
7175
+ AGCAAATT
7176
+ ACTAAACT
7177
+ CTTCGCC
7178
+ CGTATTT
7179
+ GCACGGT
7180
+ GAGCTTCT
7181
+ CCTTTTCT
7182
+ CAATAATAT
7183
+ GCTTTGATT
7184
+ CTGGGAT
7185
+ CCAAGGCC
7186
+ CAACAACAA
7187
+ GGAAGCCT
7188
+ CATAGTT
7189
+ GCTGATTT
7190
+ CTTCGTT
7191
+ GCCACGAA
7192
+ CCTCATTTT
7193
+ CCAAAGCT
7194
+ GATGATGAA
7195
+ CATTTGGTT
7196
+ GTTTTAATT
7197
+ AATGGGT
7198
+ AAATCTAA
7199
+ AGTAGAAT
7200
+ GAGGATAA
7201
+ GGCTCGGT
7202
+ AAAATAATT
7203
+ GATTATTTT
7204
+ AGGGGAGG
7205
+ CACACCAA
7206
+ GTATGGT
7207
+ GAAAAGGT
7208
+ GAGGGGAA
7209
+ GATTAACT
7210
+ GCGTGAG
7211
+ AATATGG
7212
+ GTTAGGT
7213
+ CTTTCCTTT
7214
+ CCACACT
7215
+ ACCATATT
7216
+ ACATGAG
7217
+ GGTGGTCCTT
7218
+ GCCGTCGT
7219
+ GAGTTGAT
7220
+ GCAAAACC
7221
+ CAATGCAT
7222
+ CGCACCGGACT
7223
+ GCTGACC
7224
+ GCGTTAT
7225
+ ACATTGAA
7226
+ CAAATACT
7227
+ CATTCTCT
7228
+ CATGGCC
7229
+ GATCATAT
7230
+ CACCTATTCACC
7231
+ AGATTTTCT
7232
+ GTTACCT
7233
+ AGTTGGAA
7234
+ AAAATTTTAT
7235
+ CTTCTTTTTT
7236
+ GATTTATTT
7237
+ ACACAGAT
7238
+ AGTGCAAAT
7239
+ CCTGTAA
7240
+ AATGGCAA
7241
+ CGGAAAT
7242
+ GCCGCGC
7243
+ AGAATGAA
7244
+ AGCACGG
7245
+ CGAAGAG
7246
+ CGGCGAGG
7247
+ AGGGCCT
7248
+ CGCCGTCC
7249
+ CAGTTCAA
7250
+ GCCCACC
7251
+ GCATTTTGT
7252
+ CATGACT
7253
+ ACCCACAA
7254
+ AGGAATTT
7255
+ GAGTCAATT
7256
+ CTTTAACT
7257
+ CTTTCCCAA
7258
+ ACAAACCT
7259
+ CTTGTGCT
7260
+ CAATCCAT
7261
+ GCCCCCC
7262
+ GATAAGAA
7263
+ CACTTGAA
7264
+ AGCGCGT
7265
+ CCAACCACC
7266
+ GCAACGT
7267
+ ATTTCCCC
7268
+ GAATCTAA
7269
+ AATGTGAA
7270
+ AGCATAAT
7271
+ ATATCTAA
7272
+ ATTTGTGG
7273
+ AGACCTTT
7274
+ CAAAAGGT
7275
+ CAGACTTT
7276
+ CGAGCTCC
7277
+ AAATGGAA
7278
+ ACCGTTT
7279
+ GCATATCT
7280
+ CATTGTGT
7281
+ AATGGATT
7282
+ ACGGTTTT
7283
+ ACAACGTGGAGT
7284
+ ATATCTCT
7285
+ AACAAGG
7286
+ AATTTGTAA
7287
+ GAGAAAAAT
7288
+ CACATGAT
7289
+ CGACGGGT
7290
+ GATTCTCT
7291
+ CAATAACT
7292
+ CTTTACTT
7293
+ GGTTGTGG
7294
+ CGACATAA
7295
+ AAAAAAAAAAAA
7296
+ ACCGGACAT
7297
+ GCCTAAAA
7298
+ CAGCATTT
7299
+ CACCCTCC
7300
+ ACAGTTGT
7301
+ CCCTCGAT
7302
+ ACACGTT
7303
+ CTTGGTTTT
7304
+ CCTGAGT
7305
+ GTTTTGTTTT
7306
+ GGACAGGT
7307
+ CGTTTTAT
7308
+ AGGGTGTT
7309
+ CGTACAA
7310
+ GACTTTAT
7311
+ GACATATT
7312
+ GGTTCTACT
7313
+ GCTAGTTT
7314
+ ACACCTAT
7315
+ CGCTCTT
7316
+ CCTCCCTT
7317
+ AAAAGTAT
7318
+ ACGTCGG
7319
+ CGCCGCCT
7320
+ ACGGGAA
7321
+ GTTATCAT
7322
+ GGTGATTT
7323
+ CTTTCTTTTT
7324
+ GGCCCAC
7325
+ GATGGTTTT
7326
+ GACAGGGG
7327
+ AATGGAT
7328
+ GACGAGGT
7329
+ CAATTTCAA
7330
+ AGCTAGGT
7331
+ GATGAAGT
7332
+ ATTTTTCAT
7333
+ GGTTAATT
7334
+ GTCCGAA
7335
+ CTTTACAA
7336
+ GAGAGGTT
7337
+ GGCCCCCAA
7338
+ GAAAACAGT
7339
+ CTTTCCCC
7340
+ GCTGTAA
7341
+ CGAGCAGG
7342
+ GGTTCATT
7343
+ CGACAGT
7344
+ AGAGCTAT
7345
+ CCTTCGTCC
7346
+ ATTTGAGG
7347
+ AAATAACC
7348
+ CGCATAT
7349
+ AGTGGCAA
7350
+ CATTTCCT
7351
+ CAGTCATT
7352
+ CTTTGGCT
7353
+ CGAGCAC
7354
+ AGTGGACT
7355
+ GCGAAGAA
7356
+ ACATCGT
7357
+ CTTTAACC
7358
+ CAAATCAAT
7359
+ ACCATAAT
7360
+ CATCCAC
7361
+ GCGCACT
7362
+ GCGTGAC
7363
+ GTTTGGCT
7364
+ GCTCAGCCCC
7365
+ ACGGTCT
7366
+ ATTGGTTT
7367
+ CACCGTT
7368
+ GAGTATGT
7369
+ CGGGAAT
7370
+ ACGCTAT
7371
+ AGTAAGTT
7372
+ GTTGATCTTGAT
7373
+ ACATACCT
7374
+ GATTCAGG
7375
+ GACTCAG
7376
+ AATTATTTGT
7377
+ CTAAAGGGAGAA
7378
+ GCACCGGACAT
7379
+ GAGGCACC
7380
+ ATTTATCC
7381
+ CTTTCTCTT
7382
+ ATAACATT
7383
+ GCTTTGGT
7384
+ CCAAGTGGGT
7385
+ GAGTTCTT
7386
+ ATATCTCAA
7387
+ CGGGCTT
7388
+ GCCACCTT
7389
+ AGTCCTTTT
7390
+ AACAACAA
7391
+ CACAAACC
7392
+ GAAGTGACC
7393
+ GAGATTTTT
7394
+ AGAAGTAA
7395
+ AGCCAAGT
7396
+ CAGCATAT
7397
+ AGTATCC
7398
+ GAGGTGTACGAG
7399
+ AGATCCAA
7400
+ CAGTCCT
7401
+ GAAAAGGAT
7402
+ AGATTGAA
7403
+ CACATTAT
7404
+ CCTTATAT
7405
+ GACACACC
7406
+ AATTGTAA
7407
+ GATTTTGCT
7408
+ CTTGTAAGT
7409
+ GAAAAATTT
7410
+ GGGGGTTACC
7411
+ CTTGTCT
7412
+ GGGGGCAA
7413
+ GAAATAGG
7414
+ GTGTAAGG
7415
+ GAGAAACT
7416
+ GGTTGAGG
7417
+ CTCCACAA
7418
+ ATATGTGG
7419
+ CATAAGTT
7420
+ AAAAAAATTT
7421
+ ACATCTAT
7422
+ ACCGGAA
7423
+ AAAAAGGT
7424
+ GGCTGAAT
7425
+ CATTTTATT
7426
+ CAGGTTGT
7427
+ GGTCTAA
7428
+ CCTTAACC
7429
+ ATATGTTTT
7430
+ AGCGTAA
7431
+ GCCAAAC
7432
+ CGTGGGG
7433
+ CATTTATTT
7434
+ AGGGGGT
7435
+ AAAAATGAT
7436
+ AGAAAATTTT
7437
+ AGTCGATT
7438
+ GAGCGAC
7439
+ CAGGAATT
7440
+ CTGGGAA
7441
+ GCCACCGT
7442
+ AGCACTAA
7443
+ CTTAGAA
7444
+ CTCTGGTT
7445
+ ACCTACC
7446
+ ACATCGG
7447
+ AGATAAGT
7448
+ ACATTGAT
7449
+ CGAACGG
7450
+ AATCGAT
7451
+ ATTGTACT
7452
+ ATTTTTAAAA
7453
+ CTTGGGAA
7454
+ GTTTGTCT
7455
+ GGGTACT
7456
+ AATCACC
7457
+ GCAAGGCAA
7458
+ AGATCTAT
7459
+ GCGCCTCC
7460
+ GCACAACTT
7461
+ CATTTGCT
7462
+ GAGATATTT
7463
+ ATTGTCAT
7464
+ GCAATGCT
7465
+ GTTTAAGT
7466
+ GCAATGAAT
7467
+ GTTTTCCT
7468
+ AGAGCTTT
7469
+ CAATAATACT
7470
+ CTTTTCTTTTT
7471
+ ACCAGTTTT
7472
+ AATTTAATT
7473
+ CATATGTT
7474
+ ACACACGT
7475
+ AGAGACTT
7476
+ GATGTATT
7477
+ GCAACGGT
7478
+ GACCCGG
7479
+ GTTTGATTT
7480
+ AGTAGTAT
7481
+ GAATAACC
7482
+ GGTGGTGGT
7483
+ GACGCTT
7484
+ CAGCAGTT
7485
+ CTTTGGCTTT
7486
+ CGATTTAT
7487
+ GTTTTGATT
7488
+ GCCTCACT
7489
+ GTTTCCAA
7490
+ CAATGCTT
7491
+ GCATGAG
7492
+ ACCAACAT
7493
+ CGGTGGAA
7494
+ GTTATGAT
7495
+ AGCCGCT
7496
+ CTTTTGCTT
7497
+ GTGTCGT
7498
+ GTTTTTTAT
7499
+ CATTACAA
7500
+ GTCCGAT
7501
+ GACGAAGCT
7502
+ AGGGGGAGAA
7503
+ AATATACT
7504
+ GACCCTTT
7505
+ CGAGAAGG
7506
+ GGTTGAAT
7507
+ GACATTTTT
7508
+ CAATACTT
7509
+ CTCCATGT
7510
+ GTTGGGTT
7511
+ CACTCTGT
7512
+ GACTAATT
7513
+ GGATGCAT
7514
+ GAAGGATT
7515
+ ACCATTTCTT
7516
+ CTCTCTAA
7517
+ GAATTAAGAA
7518
+ GCGGGCGG
7519
+ CGAAGCAT
7520
+ GTAAGAT
7521
+ CCTTTGCAG
7522
+ AGTTCAC
7523
+ AGAAGGGG
7524
+ GTTTGCAT
7525
+ GACCACCT
7526
+ AATCTGAA
7527
+ CTTTGTCT
7528
+ GGTAACC
7529
+ CGTAC
7530
+ GGGTATTT
7531
+ ATTCACT
7532
+ GGGAGATAT
7533
+ CATCATCT
7534
+ CATGTCTT
7535
+ ACACCATGAA
7536
+ CGCGGAT
7537
+ GCCCCAT
7538
+ GGAAACACT
7539
+ AGCGTCT
7540
+ GACCCCCC
7541
+ AGAACATT
7542
+ CCCTGAT
7543
+ CGCCATGG
7544
+ CCTTGAC
7545
+ CAAAAGGTAT
7546
+ ACTTCAG
7547
+ GAGCCAACGGT
7548
+ AAATAATTTT
7549
+ GATGGCCT
7550
+ CGGTCCT
7551
+ CGTCACT
7552
+ ACAAGTGG
7553
+ ATTAAGAT
7554
+ CGGCAGG
7555
+ ATTATTCC
7556
+ AGATCTTT
7557
+ ATATGCAA
7558
+ AGCACTCT
7559
+ CAATATCC
7560
+ GAAAACAG
7561
+ AGCCGACC
7562
+ CAGTAGG
7563
+ CCTTATTT
7564
+ AGTCCTTT
7565
+ GAGGATGT
7566
+ AGATTAAT
7567
+ GTTTAAGG
7568
+ CACTTCGG
7569
+ GACATGTT
7570
+ CAGACGT
7571
+ ACTCCATT
7572
+ CAAAACATT
7573
+ ACTTCACT
7574
+ AGCTGCTT
7575
+ GAGGATTT
7576
+ CGTTGCGAAAA
7577
+ ACATAGAT
7578
+ CACTTCTT
7579
+ CGGCCGAA
7580
+ GGAAAGGT
7581
+ ACTATCAT
7582
+ GGAGACAA
7583
+ AGTTGACT
7584
+ GCATCGCC
7585
+ GTGTTGAA
7586
+ ATTTTATCT
7587
+ GACACCTT
7588
+ GCCGACT
7589
+ CATGGAAT
7590
+ CGAAAACC
7591
+ ATATATAAT
7592
+ GACAACAT
7593
+ GTTCATTT
7594
+ GGTAATTT
7595
+ CAATCTCT
7596
+ GCGCGGCC
7597
+ CGTAGGAGT
7598
+ CCTTAAAT
7599
+ GATTGCTT
7600
+ CGTTATT
7601
+ ACAGAGAT
7602
+ AAAATCTT
7603
+ ACAAGGAT
7604
+ GCATATGG
7605
+ ATTTTCTAT
7606
+ CATCCATT
7607
+ CTTCTACT
7608
+ GTCTAGT
7609
+ ATTTTGGTT
7610
+ AGATTCTT
7611
+ AGCTTCAG
7612
+ CGTGTAT
7613
+ CAATACAT
7614
+ GTCCCGG
7615
+ GGGTCCT
7616
+ GCTCGCT
7617
+ GAATAGAT
7618
+ GAAATCCT
7619
+ AAGGAGAGG
7620
+ GATTTGATT
7621
+ ATTTTTATTT
7622
+ GCGATAA
7623
+ CACTCTTT
7624
+ AAAAATATTT
7625
+ GCTTATTT
7626
+ GCGTCTCC
7627
+ GAGTAAAT
7628
+ GACAAAATT
7629
+ GAAGACT
7630
+ GCAACCTT
7631
+ GCCGGACC
7632
+ GCATTGAT
7633
+ CCCTAATT
7634
+ CCTAGGGT
7635
+ GAAGTCTCT
7636
+ GGTTGCACT
7637
+ ACGTGAT
7638
+ GACCCTAA
7639
+ GAAGGAAT
7640
+ GAGTTGGT
7641
+ AATAAACTGT
7642
+ CCAAGTGG
7643
+ ATTCTGAT
7644
+ GACATCAAGT
7645
+ GAGAATAT
7646
+ GGTATGAA
7647
+ CGACACGG
7648
+ GATTCAC
7649
+ AGCCACTT
7650
+ GACTCAAAT
7651
+ GAAAAGGAA
7652
+ GGCCTGG
7653
+ CAGCACAA
7654
+ GGGAGAGG
7655
+ CTTCGGT
7656
+ CAGGAAAT
7657
+ GACAAGTT
7658
+ GGGGATAA
7659
+ GACACATT
7660
+ GCCTCCCC
7661
+ CAGAATAT
7662
+ GAGGCGGT
7663
+ GCTTAAGT
7664
+ ATGTACC
7665
+ ACGTATT
7666
+ ATATAGAA
7667
+ GCTTGGAA
7668
+ GTTGTAAT
7669
+ CAGGGTAT
7670
+ CGCCAGG
7671
+ CACTATTT
7672
+ AGTCTGT
7673
+ CCTCTCCT
7674
+ GAATAAGG
7675
+ AGAATCAT
7676
+ ACACTTAA
7677
+ GACATTAT
7678
+ GTGTTTTTT
7679
+ GACAAAAAT
7680
+ GCATACTT
7681
+ GAGACGCC
7682
+ GTTTACCT
7683
+ GCAAGGTT
7684
+ ACCTTTCC
7685
+ GGCTGAGT
7686
+ GCACGTT
7687
+ ACGCGAA
7688
+ AGTGGAC
7689
+ AGCATGAT
7690
+ CAGGCAGG
7691
+ GATCCATT
7692
+ GATCTCGTT
7693
+ ACAAAAATT
7694
+ CCGGCAT
7695
+ GAGCAAAT
7696
+ GCCTTGATT
7697
+ ACAACTAT
7698
+ GTCCAAAT
7699
+ GCAAATGG
7700
+ CAGGATCC
7701
+ GAGATCAT
7702
+ GAGGATGG
7703
+ CGCCCGT
7704
+ AGATCAATT
7705
+ GGTGAAGT
7706
+ GAGCTTCGG
7707
+ CACTATAT
7708
+ ACAAGTAA
7709
+ AATTCATTT
7710
+ AATAATAA
7711
+ GGGTGACC
7712
+ ACCCATTT
7713
+ GAATCTAT
7714
+ CAATCATT
7715
+ GACTGGGG
7716
+ ATATATATAA
7717
+ GCTCAACAT
7718
+ CTCTATCC
7719
+ GCCCAGT
7720
+ GGCCCGGCC
7721
+ CAGCAGAA
7722
+ AAAACTAT
7723
+ CCTCCTTTT
7724
+ AGGTGTAAGCCT
7725
+ ACTTCTAA
7726
+ CTTTGAGT
7727
+ CCATGTTCC
7728
+ CGTCGAGG
7729
+ CCCTAGT
7730
+ ATTTTGTTTT
7731
+ GCATAATTT
7732
+ ACAAAATAT
7733
+ GTGGAGAA
7734
+ ATTGTCTT
7735
+ GAGAATTTT
7736
+ GACAATGG
7737
+ CAAAAGGGG
7738
+ CGCAGCAA
7739
+ GATCTAAT
7740
+ CGAAGCTT
7741
+ GGTATCAG
7742
+ ACCATCAT
7743
+ CCGTCGG
7744
+ CATCAAATT
7745
+ AGAAAACAA
7746
+ CGAGCTCT
7747
+ GCATGGAT
7748
+ CGCCAAT
7749
+ GTGTGTCT
7750
+ GATTGGCC
7751
+ ATTTTACC
7752
+ CCTTCCAT
7753
+ CCTTAACAT
7754
+ CAAAACCT
7755
+ GACAGCAA
7756
+ AGCCACTTGG
7757
+ AAGGGGGT
7758
+ CAATGCAA
7759
+ AGTGTGAT
7760
+ GAGACGAA
7761
+ GCACAATT
7762
+ AGTTCGG
7763
+ AGAGGTAT
7764
+ CCAACACT
7765
+ AGTATGAA
7766
+ AGCCACCT
7767
+ GACCAAATT
7768
+ AGAAAGGT
7769
+ GCCTCACC
7770
+ AAAAATGTT
7771
+ GGCTACC
7772
+ CTTTTCCTTT
7773
+ GCAGATCC
7774
+ GAATGGAA
7775
+ AAAGAGAT
7776
+ ACAATAAAT
7777
+ GAGGGTCGG
7778
+ ATTATAAAT
7779
+ ACAGGTTT
7780
+ CAGCCTCT
7781
+ GA
7782
+ CAATCGT
7783
+ GAAGGAAAA
7784
+ CTTTTAATT
7785
+ CGACATCT
7786
+ CTTGGCAA
7787
+ CCTTAGGAA
7788
+ ACAATGAT
7789
+ ATCCCAT
7790
+ GCGGCCT
7791
+ CTTAACT
7792
+ GGTTGATTT
7793
+ CTGGCAT
7794
+ CGAAACAA
7795
+ ACATGCTTT
7796
+ CTTAAAGG
7797
+ AGAGCCAA
7798
+ GCATTGAA
7799
+ CGTCCGTTGG
7800
+ AGCAAAATT
7801
+ GGACGAC
7802
+ GGTATTTTT
7803
+ GAGTGACT
7804
+ GCTGACT
7805
+ AATTAACAT
7806
+ GGATATTT
7807
+ AGTTGTGG
7808
+ ACAGCTTT
7809
+ CAGCAGCT
7810
+ CAGCAATT
7811
+ GCCAAGAT
7812
+ AATCCTTTT
7813
+ CCCCAAAA
7814
+ CAAATAGT
7815
+ GAAGGGAA
7816
+ AGACTCAA
7817
+ CACTTCGCC
7818
+ GGCCGGT
7819
+ AGCTTCGT
7820
+ GCAGATGT
7821
+ ATTTTGCC
7822
+ AGCATACT
7823
+ CAATGAG
7824
+ AGGTATAT
7825
+ GACTATGT
7826
+ ATCCACT
7827
+ CATATACT
7828
+ CTTTCTGT
7829
+ GCAAGAACC
7830
+ CGCCCCT
7831
+ GAGCCCCT
7832
+ GCTTTTGG
7833
+ ACAAAAGG
7834
+ GCGGTTTAAGTT
7835
+ CGCACAC
7836
+ GGAACCCAA
7837
+ GCAATTGT
7838
+ CATTTTTAA
7839
+ CGACCGG
7840
+ GCAATATT
7841
+ GACATGAT
7842
+ GCACAAGT
7843
+ ATGTAACT
7844
+ AGCAAGAT
7845
+ GGAGCCTCT
7846
+ GCGCGGT
7847
+ ATTGGGCC
7848
+ AACCACAA
7849
+ CTTTTTCAA
7850
+ AATTAATTTT
7851
+ GCATCCAT
7852
+ AAAAATTCT
7853
+ CAGATTGT
7854
+ GAAGAAATT
7855
+ CCAAGGTT
7856
+ GGAAGAGGT
7857
+ GTCTCGG
7858
+ ACAGTGTT
7859
+ CTTGGGTT
7860
+ GCTTGGCAT
7861
+ GAGGCAC
7862
+ AGACTTAA
7863
+ CTCCATTT
7864
+ AGTGGAGG
7865
+ GCCGCCGG
7866
+ ATGTATCT
7867
+ CTTTGCGG
7868
+ AAAAAACAT
7869
+ CTAAGTGTT
7870
+ GGAGCAC
7871
+ GATTGCAA
7872
+ ACCTCGCC
7873
+ CCATGGTT
7874
+ GTTAACAT
7875
+ GTATAGG
7876
+ ACCTTGAT
7877
+ CGAAGGCC
7878
+ CTTAACAT
7879
+ GAATGCAT
7880
+ ACGGATT
7881
+ GGTAGGT
7882
+ CGGCTAGG
7883
+ ATTATACT
7884
+ CTTTTCTCT
7885
+ GAGAGAGAGAG
7886
+ AGTAACAT
7887
+ GATTTTTAT
7888
+ CTTCAGG
7889
+ AATAAAGG
7890
+ ACGTCGCC
7891
+ ATGTCATT
7892
+ CTCCGCCTCGCC
7893
+ AATGGCTCT
7894
+ AAAAGTAA
7895
+ GAGAGATT
7896
+ GAGTAAGT
7897
+ CTTTAGTT
7898
+ CGAAACGCC
7899
+ GTGTGGTT
7900
+ GTATCGT
7901
+ GACACTAT
7902
+ GTTGAACC
7903
+ GATAACAT
7904
+ GCCTTGAAT
7905
+ GAATTGGT
7906
+ ACAAAGCT
7907
+ CAAGGTTTT
7908
+ CCAAGCAT
7909
+ AGAGAAGG
7910
+ GGGTATGG
7911
+ CGGATAT
7912
+ CCTTGACC
7913
+ GCTTAGAA
7914
+ CAGTAAAT
7915
+ AAGTGCAA
7916
+ GCTCTGG
7917
+ AATAGGT
7918
+ AAAATATAA
7919
+ CAGTCAGG
7920
+ CTCTAAGAA
7921
+ CGGGTGG
7922
+ CATAAACT
7923
+ GAGAAAATT
7924
+ GACGTAA
7925
+ ACCCGCT
7926
+ GACCAAGG
7927
+ GCTGCAC
7928
+ GTATAAAA
7929
+ AGGCCACAA
7930
+ CCTTCGTT
7931
+ ATGTACTT
7932
+ GAACTAT
7933
+ CTTTTGTGT
7934
+ GCATGAAAA
7935
+ CGAGAC
7936
+ CACCGGAA
7937
+ ACTAACTT
7938
+ GAGCAATT
7939
+ CGCAAAG
7940
+ CGCCTCCT
7941
+ ATTTAAATTT
7942
+ ACCAGAG
7943
+ GAGGTTAT
7944
+ GAGTATGG
7945
+ CGATTTGT
7946
+ ATTTTGTGT
7947
+ CGCGCAA
7948
+ CTCATCAT
7949
+ GCTCTACTT
7950
+ CCTCCGAGG
7951
+ AGACTTAT
7952
+ GCACGAGTT
7953
+ CTAAGTAA
7954
+ AAATTAAAA
7955
+ GGTTGGAT
7956
+ ACACCTAA
7957
+ ACCTAACC
7958
+ CAAGTCTT
7959
+ AGCTCAAT
7960
+ CGACACT
7961
+ ACGTTCAT
7962
+ CTCCGTTCC
7963
+ CGCTTTTT
7964
+ CAGAACAT
7965
+ CGAAGGTT
7966
+ CACACGCC
7967
+ ATTGTGG
7968
+ GCCAAACC
7969
+ GGAAACATT
7970
+ GCTCAAAA
7971
+ GCACTTAT
7972
+ CCAACCCAA
7973
+ CTTATCAT
7974
+ ACCTAAAT
7975
+ AATGTCT
7976
+ AATAAGG
7977
+ CTTGGGCCATTT
7978
+ ACATTTTGT
7979
+ ACGGCGT
7980
+ CCCCCTCC
7981
+ GGTGAGTT
7982
+ AATACATT
7983
+ CGGCTAT
7984
+ GGTCGAG
7985
+ CATTATGG
7986
+ AGAACTAA
7987
+ GACTCTAT
7988
+ CTTCCCTT
7989
+ CCTATGCT
7990
+ ATTTGATCT
7991
+ ACTCATTTT
7992
+ GGCCGAGT
7993
+ CCCCACAT
7994
+ AGTGGAGT
7995
+ AATCAATT
7996
+ CGGATGG
7997
+ ACTACTAT
7998
+ CCTCCTTT
7999
+ T
8000
+ A
8001
+ C
8002
+ G
8003
+ N